// This function expects initialized mpz integers in all array fields between `from` and `to`.
//
// Algorithm 15.3 [PDF page 20](http://cr.yp.to/lineartime/dcba-20040404.pdf)
//
// See [split test](test-split.html) for basic usage.
void split(mpz_array *ret, const mpz_t a, mpz_t *p, size_t from, size_t to) {
mpz_t b, x;
size_t n = to - from;
// **Sep 2**
//
// Compute b ← ppi(a,prodP)
mpz_init(x);
mpz_init(b);
prod(x, p, from, to);
ppi(b, a, x);
mpz_clear(x);
// **Sep 2**
//
// If #P = 1: find p ∈ P, print (p,b), and stop
if (n == 0) {
array_add(ret, b);
mpz_clear(b);
return;
}
// **Sep 3**
//
// Select Q ⊆ P with #Q = b#P/2c.
split(ret, b, p, from, to - n/2 - 1);
split(ret, b, p, to - n/2, to);
// Free the memory.
mpz_clear(b);
}
static void
output(int on1, int on2) /* print items from olist */
{
int i;
const char *temp;
if (no <= 0) { /* default case */
printf("%s", on1? ppi(F1, j1): on2? ppi(F2, j2) : null);
for (i = 0; i < on1; i++)
if (i != j1) {
if (mb_cur_max > 1)
printf("%lc%s",(wint_t)sep1,ppi(F1, i));
else
printf("%c%s", (int)sep1, ppi(F1, i));
}
for (i = 0; i < on2; i++)
if (i != j2) {
if (mb_cur_max > 1)
printf("%lc%s",(wint_t)sep1,ppi(F2, i));
else
printf("%c%s", (int)sep1, ppi(F2, i));
}
printf("\n");
} else {
for (i = 0; i < no; i++) {
temp = ppi(olistf[i], olist[i]);
if(olistf[i]==F1 && on1<=olist[i] ||
olistf[i]==F2 && on2<=olist[i])
temp = null;
else if (olistf[i]==JF) {
if (on1)
temp = ppi(F1, j1);
else if (on2)
temp = ppi(F2, j2);
else
temp = null;
}
if (temp == 0 || *temp == 0)
temp = null;
printf("%s", temp ? temp : null);
if (i == no - 1)
printf("\n");
else if (mb_cur_max > 1)
printf("%lc", (wint_t)sep1);
else
printf("%c", (int)sep1);
}
}
}
// Builds a lookup for finding PP matrix element indices given
// single particle configurations
boost::tuple< PPIndices, Indexsizes >
build_ppindices( const SingleParticleModelspace &spms ) {
PPIndices ppi(3); ppi.resize(3);
Indexsizes sizes(3); sizes.resize(3);
for ( int tz = -1; tz <= 1; ++tz ) {
ppi [ tz + 1 ].resize(2);
sizes[ tz + 1 ].resize(2);
for ( int parity = -1; parity <= 1; parity += 2 ) {
int maxJ = get_max_pp_J( spms, tz, parity );
ppi [ tz + 1 ][ (parity + 1)/2 ].resize( maxJ + 1 );
sizes[ tz + 1 ][ (parity + 1)/2 ].resize( maxJ + 1 );
for ( int J = 0;
J < static_cast<int>(ppi[tz + 1][(parity + 1)/2].size());
++J ) {
boost::tie( ppi [ tz + 1 ][ (parity + 1)/2 ][ J ],
sizes[ tz + 1 ][ (parity + 1)/2 ][ J ] )
= make_pp_indices( tz, parity, J, spms ); } } }
return boost::make_tuple( ppi, sizes );
}
void pulsar_state::pulsar(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, 4_MHz_XTAL);
m_maincpu->set_addrmap(AS_PROGRAM, &pulsar_state::mem_map);
m_maincpu->set_addrmap(AS_IO, &pulsar_state::io_map);
m_maincpu->set_daisy_config(daisy_chain_intf);
/* Devices */
i8255_device &ppi(I8255(config, "ppi"));
ppi.out_pa_callback().set(FUNC(pulsar_state::ppi_pa_w));
ppi.out_pb_callback().set(FUNC(pulsar_state::ppi_pb_w));
ppi.in_pc_callback().set(FUNC(pulsar_state::ppi_pc_r));
ppi.out_pc_callback().set(FUNC(pulsar_state::ppi_pc_w));
MSM5832(config, "rtc", 32.768_kHz_XTAL);
z80dart_device& dart(Z80DART(config, "dart", 4_MHz_XTAL));
dart.out_txda_callback().set("rs232", FUNC(rs232_port_device::write_txd));
dart.out_dtra_callback().set("rs232", FUNC(rs232_port_device::write_dtr));
dart.out_rtsa_callback().set("rs232", FUNC(rs232_port_device::write_rts));
dart.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, "terminal"));
rs232.rxd_handler().set("dart", FUNC(z80dart_device::rxa_w));
rs232.cts_handler().set("dart", FUNC(z80dart_device::ctsa_w));
rs232.set_option_device_input_defaults("terminal", DEVICE_INPUT_DEFAULTS_NAME(terminal));
com8116_device &brg(COM8116(config, "brg", 5.0688_MHz_XTAL));
// Schematic has the labels for FT and FR the wrong way around, but the pin numbers are correct.
brg.fr_handler().set("dart", FUNC(z80dart_device::txca_w));
brg.fr_handler().append("dart", FUNC(z80dart_device::rxca_w));
brg.ft_handler().set("dart", FUNC(z80dart_device::txcb_w));
brg.ft_handler().append("dart", FUNC(z80dart_device::rxcb_w));
FD1797(config, m_fdc, 4_MHz_XTAL / 2);
FLOPPY_CONNECTOR(config, "fdc:0", pulsar_floppies, "flop", floppy_image_device::default_floppy_formats).enable_sound(true);
FLOPPY_CONNECTOR(config, "fdc:1", pulsar_floppies, "flop", floppy_image_device::default_floppy_formats).enable_sound(true);
}
GFXDECODE_END
/*************************
* Machine Drivers *
*************************/
void gatron_state::gat(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, CPU_CLOCK);
m_maincpu->set_addrmap(AS_PROGRAM, &gatron_state::gat_map);
m_maincpu->set_addrmap(AS_IO, &gatron_state::gat_portmap);
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
i8255_device &ppi(I8255A(config, "ppi8255"));
ppi.in_pa_callback().set_ioport("IN0");
ppi.in_pb_callback().set_ioport("IN1");
ppi.out_pc_callback().set(FUNC(gatron_state::output_port_1_w));
/* video hardware */
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(48*8, 16*16);
screen.set_visarea(0*8, 48*8-1, 0*8, 16*16-1);
screen.set_screen_update(FUNC(gatron_state::screen_update));
screen.set_palette("palette");
screen.screen_vblank().set_inputline(m_maincpu, INPUT_LINE_NMI);
GFXDECODE(config, m_gfxdecode, "palette", gfx_gat);
PALETTE(config, "palette").set_entries(8);
/* sound hardware */
SPEAKER(config, "mono").front_center();
SN76489(config, "snsnd", MASTER_CLOCK/8).add_route(ALL_OUTPUTS, "mono", 2.00); // Present in Bingo PCB. Clock need to be verified.
}
// This algorithm factors each element a ∈ S over P if P is a base for S; otherwise it proclaims failure.
//
// Algorithm 21.2 [PDF page 27](http://cr.yp.to/lineartime/dcba-20040404.pdf)
//
// See [findfactors test](test-findfactors.html) for basic usage.
void find_factors(mpz_array *out, mpz_t *s, size_t from, size_t to, mpz_array *p) {
mpz_t x, y, z;
mpz_array d, q;
size_t i, n = to - from;
mpz_init(x);
array_prod(p, x);
mpz_init(y);
prod(y, s, from, to);
mpz_init(z);
ppi(z, x, y);
array_init(&d, p->size);
array_split(&d, z, p);
array_init(&q, p->size);
for (i = 0; i < p->used; i++) {
if (mpz_cmp(d.array[i], p->array[i]) == 0)
array_add(&q, p->array[i]);
}
if (n == 0) {
array_find_factor(out, y, &q);
} else {
find_factors(out, s, from, to - n/2 - 1, &q);
find_factors(out, s, to - n/2, to, &q);
}
mpz_clear(x);
mpz_clear(y);
mpz_clear(z);
array_clear(&d);
array_clear(&q);
}
void iq151_state::iq151(machine_config &config)
{
/* basic machine hardware */
I8080(config, m_maincpu, XTAL(2'000'000));
m_maincpu->set_addrmap(AS_PROGRAM, &iq151_state::iq151_mem);
m_maincpu->set_addrmap(AS_IO, &iq151_state::iq151_io);
m_maincpu->set_vblank_int("screen", FUNC(iq151_state::iq151_vblank_interrupt));
m_maincpu->set_irq_acknowledge_callback("pic8259", FUNC(pic8259_device::inta_cb));
/* video hardware */
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER, rgb_t::green()));
screen.set_refresh_hz(50);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_screen_update(FUNC(iq151_state::screen_update));
screen.set_size(64*8, 32*8);
screen.set_visarea(0, 32*8-1, 0, 32*8-1);
screen.set_palette("palette");
PALETTE(config, "palette", palette_device::MONOCHROME);
/* sound hardware */
SPEAKER(config, "mono").front_center();
SPEAKER_SOUND(config, m_speaker).add_route(ALL_OUTPUTS, "mono", 0.50);
PIC8259(config, m_pic, 0);
m_pic->out_int_callback().set_inputline(m_maincpu, 0);
i8255_device &ppi(I8255(config, "ppi8255"));
ppi.in_pa_callback().set(FUNC(iq151_state::keyboard_row_r));
ppi.in_pb_callback().set(FUNC(iq151_state::keyboard_column_r));
ppi.in_pc_callback().set(FUNC(iq151_state::ppi_portc_r));
ppi.out_pc_callback().set(FUNC(iq151_state::ppi_portc_w));
CASSETTE(config, m_cassette);
m_cassette->set_default_state(CASSETTE_STOPPED);
m_cassette->set_interface("iq151_cass");
TIMER(config, "cassette_timer").configure_periodic(FUNC(iq151_state::cassette_timer), attotime::from_hz(2000));
/* cartridge */
IQ151CART_SLOT(config, m_carts[0], iq151_cart, nullptr);
m_carts[0]->set_screen_tag("screen");
m_carts[0]->out_irq0_callback().set(m_pic, FUNC(pic8259_device::ir0_w));
m_carts[0]->out_irq1_callback().set(m_pic, FUNC(pic8259_device::ir1_w));
m_carts[0]->out_irq2_callback().set(m_pic, FUNC(pic8259_device::ir2_w));
m_carts[0]->out_irq3_callback().set(m_pic, FUNC(pic8259_device::ir3_w));
m_carts[0]->out_irq4_callback().set(m_pic, FUNC(pic8259_device::ir4_w));
IQ151CART_SLOT(config, m_carts[1], iq151_cart, nullptr);
m_carts[1]->set_screen_tag("screen");
m_carts[1]->out_irq0_callback().set(m_pic, FUNC(pic8259_device::ir0_w));
m_carts[1]->out_irq1_callback().set(m_pic, FUNC(pic8259_device::ir1_w));
m_carts[1]->out_irq2_callback().set(m_pic, FUNC(pic8259_device::ir2_w));
m_carts[1]->out_irq3_callback().set(m_pic, FUNC(pic8259_device::ir3_w));
m_carts[1]->out_irq4_callback().set(m_pic, FUNC(pic8259_device::ir4_w));
IQ151CART_SLOT(config, m_carts[2], iq151_cart, nullptr);
m_carts[2]->set_screen_tag("screen");
m_carts[2]->out_irq0_callback().set(m_pic, FUNC(pic8259_device::ir0_w));
m_carts[2]->out_irq1_callback().set(m_pic, FUNC(pic8259_device::ir1_w));
m_carts[2]->out_irq2_callback().set(m_pic, FUNC(pic8259_device::ir2_w));
m_carts[2]->out_irq3_callback().set(m_pic, FUNC(pic8259_device::ir3_w));
m_carts[2]->out_irq4_callback().set(m_pic, FUNC(pic8259_device::ir4_w));
IQ151CART_SLOT(config, m_carts[3], iq151_cart, nullptr);
m_carts[3]->set_screen_tag("screen");
m_carts[3]->out_irq0_callback().set(m_pic, FUNC(pic8259_device::ir0_w));
m_carts[3]->out_irq1_callback().set(m_pic, FUNC(pic8259_device::ir1_w));
m_carts[3]->out_irq2_callback().set(m_pic, FUNC(pic8259_device::ir2_w));
m_carts[3]->out_irq3_callback().set(m_pic, FUNC(pic8259_device::ir3_w));
m_carts[3]->out_irq4_callback().set(m_pic, FUNC(pic8259_device::ir4_w));
IQ151CART_SLOT(config, m_carts[4], iq151_cart, "video32");
m_carts[4]->set_screen_tag("screen");
m_carts[4]->out_irq0_callback().set(m_pic, FUNC(pic8259_device::ir0_w));
m_carts[4]->out_irq1_callback().set(m_pic, FUNC(pic8259_device::ir1_w));
m_carts[4]->out_irq2_callback().set(m_pic, FUNC(pic8259_device::ir2_w));
m_carts[4]->out_irq3_callback().set(m_pic, FUNC(pic8259_device::ir3_w));
m_carts[4]->out_irq4_callback().set(m_pic, FUNC(pic8259_device::ir4_w));
/* Software lists */
SOFTWARE_LIST(config, "cart_list").set_original("iq151_cart");
SOFTWARE_LIST(config, "flop_list").set_original("iq151_flop");
}
int main( int argc, const char** argv)
{
try
{
g_errorBuffer = strus::createErrorBuffer_standard( 0, 1);
if (!g_errorBuffer)
{
std::cerr << "construction of error buffer failed" << std::endl;
return -1;
}
else if (argc > 3)
{
printUsage( argc, argv);
std::cerr << "too many arguments" << std::endl;
return 1;
}
else if (argc < 3)
{
printUsage( argc, argv);
std::cerr << "too few arguments" << std::endl;
return 1;
}
// Create objects:
std::auto_ptr<strus::TokenPatternMatchInterface> pti( strus::createTokenPatternMatch_standard( g_errorBuffer));
if (!pti.get()) throw std::runtime_error("failed to create pattern matcher");
std::auto_ptr<strus::CharRegexMatchInterface> cri( strus::createCharRegexMatch_standard( g_errorBuffer));
if (!cri.get()) throw std::runtime_error("failed to create char regex matcher");
std::auto_ptr<strus::PatternMatchProgramInterface> ppi( strus::createPatternMatchProgram_standard( pti.get(), cri.get(), g_errorBuffer));
if (!ppi.get()) throw std::runtime_error("failed to create pattern program loader");
std::auto_ptr<strus::PatternMatchProgramInstanceInterface> pii( ppi->createInstance());
if (!pii.get()) throw std::runtime_error("failed to create pattern program loader instance");
// Load program:
std::string programfile( argv[ 1]);
std::string programsrc;
unsigned int ec;
ec = strus::readFile( programfile, programsrc);
if (ec)
{
char errmsg[ 256];
::snprintf( errmsg, sizeof(errmsg), "error (%u) reading program source '%s': %s", ec, programfile.c_str(), ::strerror(ec));
throw std::runtime_error( errmsg);
}
if (!pii->load( programsrc))
{
throw std::runtime_error( "error loading pattern match program source");
}
if (!pii->compile())
{
throw std::runtime_error( "error compiling pattern match program");
}
// Load input:
std::string inputfile( argv[ 2]);
std::string inputsrc;
ec = strus::readFile( inputfile, inputsrc);
if (ec)
{
char errmsg[ 256];
::snprintf( errmsg, sizeof(errmsg), "error (%u) reading input file '%s': %s", ec, inputfile.c_str(), ::strerror(ec));
throw std::runtime_error( errmsg);
}
// Load expected output:
char const* argv2ext = std::strchr( argv[ 2], '.');
if (argv2ext)
{
char const* aa = std::strchr( argv2ext+1, '.');
while (aa)
{
argv2ext = aa;
aa = std::strchr( argv2ext+1, '.');
}
}
else
{
argv2ext = std::strchr( argv[ 2], '\0');
}
std::string expectedfile( argv[ 2], argv2ext - argv[ 2]);
expectedfile.append( ".res");
std::string expectedsrc;
ec = strus::readFile( expectedfile, expectedsrc);
if (ec)
{
char errmsg[ 256];
::snprintf( errmsg, sizeof(errmsg), "error (%u) reading expected file '%s': %s", ec, expectedfile.c_str(), ::strerror(ec));
throw std::runtime_error( errmsg);
}
// Scan source with char regex automaton for tokens:
const strus::CharRegexMatchInstanceInterface* crinst = pii->getCharRegexMatchInstance();
std::auto_ptr<strus::CharRegexMatchContextInterface> crctx( crinst->createContext());
std::vector<strus::stream::PatternMatchToken> crmatches = crctx->match( inputsrc.c_str(), inputsrc.size());
if (crmatches.size() == 0 && g_errorBuffer->hasError())
{
throw std::runtime_error( "failed to scan for tokens with char regex match automaton");
}
std::ostringstream resultstrbuf;
// Scan tokens with token pattern match automaton and print results:
const strus::TokenPatternMatchInstanceInterface* ptinst = pii->getTokenPatternMatchInstance();
std::auto_ptr<strus::TokenPatternMatchContextInterface> ptctx( ptinst->createContext());
std::vector<strus::stream::PatternMatchToken>::const_iterator
ci = crmatches.begin(), ce = crmatches.end();
for (; ci != ce; ++ci)
{
std::string tokstr( std::string( inputsrc.c_str() + ci->origpos(), ci->origsize()));
resultstrbuf << "token " << pii->tokenName(ci->id()) << "(" << ci->id() << ") at " << ci->ordpos()
<< "[" << ci->origpos() << ":" << ci->origsize() << "] '"
<< tokstr << "'" << std::endl;
ptctx->putInput( *ci);
}
std::vector<strus::stream::TokenPatternMatchResult> results = ptctx->fetchResults();
if (results.size() == 0 && g_errorBuffer->hasError())
{
throw std::runtime_error( "failed to scan for patterns with token pattern match automaton");
}
// Print results to buffer:
strus::utils::printResults( resultstrbuf, results, inputsrc.c_str());
strus::stream::TokenPatternMatchStatistics stats = ptctx->getStatistics();
strus::utils::printStatistics( resultstrbuf, stats);
// Print result to stdout and verify result by comparing it with the expected output:
std::string resultstr = resultstrbuf.str();
std::cout << resultstr << std::endl;
if (!diffContent( expectedsrc, resultstr))
{
throw std::runtime_error( "output and expected result differ");
}
if (g_errorBuffer->hasError())
{
throw std::runtime_error( "uncaught error");
}
std::cerr << "OK" << std::endl;
delete g_errorBuffer;
return 0;
}
catch (const std::runtime_error& err)
{
if (g_errorBuffer->hasError())
{
std::cerr << "error processing pattern matching: "
<< g_errorBuffer->fetchError() << " (" << err.what()
<< ")" << std::endl;
}
else
{
std::cerr << "error processing pattern matching: "
<< err.what() << std::endl;
}
}
catch (const std::bad_alloc&)
{
std::cerr << "out of memory processing pattern matching" << std::endl;
}
delete g_errorBuffer;
return -1;
}
void mrgame_state::mrgame(machine_config &config)
{
/* basic machine hardware */
M68000(config, m_maincpu, 6_MHz_XTAL);
m_maincpu->set_addrmap(AS_PROGRAM, &mrgame_state::main_map);
m_maincpu->set_periodic_int(FUNC(mrgame_state::irq1_line_hold), attotime::from_hz(183));
Z80(config, m_videocpu, 18.432_MHz_XTAL / 6);
m_videocpu->set_addrmap(AS_PROGRAM, &mrgame_state::video_map);
Z80(config, m_audiocpu1, 4_MHz_XTAL);
m_audiocpu1->set_addrmap(AS_PROGRAM, &mrgame_state::audio1_map);
m_audiocpu1->set_addrmap(AS_IO, &mrgame_state::audio1_io);
Z80(config, m_audiocpu2, 4_MHz_XTAL);
m_audiocpu2->set_addrmap(AS_PROGRAM, &mrgame_state::audio2_map);
m_audiocpu2->set_addrmap(AS_IO, &mrgame_state::audio2_io);
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0); // 5564 (x2) + battery
LS259(config, m_selectlatch); // 5B
m_selectlatch->q_out_cb<0>().set(FUNC(mrgame_state::video_a11_w));
m_selectlatch->q_out_cb<1>().set(FUNC(mrgame_state::nmi_intst_w));
m_selectlatch->q_out_cb<3>().set(FUNC(mrgame_state::video_a12_w));
m_selectlatch->q_out_cb<4>().set(FUNC(mrgame_state::video_a13_w));
m_selectlatch->q_out_cb<6>().set(FUNC(mrgame_state::flip_w));
//watchdog_timer_device &watchdog(WATCHDOG_TIMER(config, "watchdog")); // LS393 at 5D (video board) driven by VBLANK
//watchdog.set_vblank_count("screen", 8);
/* video hardware */
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_raw(18.432_MHz_XTAL / 3, 384, 0, 256, 264, 8, 248); // If you align with X on test screen some info is chopped off
screen.set_screen_update(FUNC(mrgame_state::screen_update_mrgame));
screen.set_palette(m_palette);
screen.screen_vblank().set(FUNC(mrgame_state::vblank_nmi_w));
PALETTE(config, m_palette, FUNC(mrgame_state::mrgame_palette), 64);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_mrgame);
/* Sound */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
DAC_8BIT_R2R(config, "ldac", 0).add_route(ALL_OUTPUTS, "lspeaker", 0.25); // unknown DAC
DAC_8BIT_R2R(config, "rdac", 0).add_route(ALL_OUTPUTS, "rspeaker", 0.25); // unknown DAC
dac_8bit_r2r_device &dacvol(DAC_8BIT_R2R(config, "dacvol", 0)); // unknown DAC
dacvol.add_route(0, "ldac", 1.0, DAC_VREF_POS_INPUT);
dacvol.add_route(0, "ldac", -1.0, DAC_VREF_NEG_INPUT);
dacvol.add_route(0, "rdac", 1.0, DAC_VREF_POS_INPUT);
dacvol.add_route(0, "rdac", -1.0, DAC_VREF_NEG_INPUT);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dacvol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dacvol", -1.0, DAC_VREF_NEG_INPUT);
tms5220_device &tms(TMS5220(config, "tms", 672000)); // uses a RC combination. 672k copied from jedi.h
tms.ready_cb().set_inputline("audiocpu2", Z80_INPUT_LINE_BOGUSWAIT);
tms.add_route(ALL_OUTPUTS, "lspeaker", 1.0);
tms.add_route(ALL_OUTPUTS, "rspeaker", 1.0);
/* Devices */
TIMER(config, "irq_timer").configure_periodic(FUNC(mrgame_state::irq_timer), attotime::from_hz(16000)); //ugh
i8255_device &ppi(I8255A(config, "ppi"));
ppi.in_pa_callback().set(FUNC(mrgame_state::porta_r));
ppi.out_pb_callback().set(FUNC(mrgame_state::portb_w));
ppi.in_pc_callback().set(FUNC(mrgame_state::portc_r));
}
int
main(int argc, char **argv)
{
int i;
int n1, n2;
off_t top2 = 0, bot2;
char *arg = 0, *x;
progname = basename(argv[0]);
setlocale(LC_COLLATE, "");
setlocale(LC_CTYPE, "");
mb_cur_max = MB_CUR_MAX;
while (argc > 1 && argv[1][0] == '-') {
if (argv[1][1] == '\0')
break;
switch (argv[1][1]) {
case 'a':
if (argv[1][2])
arg = &argv[1][2];
else if (argv[2]) {
arg = argv[2];
argv++, argc--;
} else
arg = "3";
switch(*arg) {
case '1':
aflg |= 1;
break;
case '2':
aflg |= 2;
break;
default:
aflg |= 3;
}
break;
case 'e':
if (argv[1][2])
null = &argv[1][2];
else if (argv[2]) {
null = argv[2];
argv++;
argc--;
} else
usage();
break;
case 't':
if (argv[1][2]) {
int n;
next(sep1, &argv[1][2], n);
sep2 = sep1;
} else if (argv[2]) {
int n;
next(sep1, argv[2], n);
sep2 = sep1;
argv++, argc--;
} else
usage();
break;
case 'o':
if (argv[2] == NULL)
usage();
arg = argv[1][2] ? &argv[1][2] : argv[2];
for (no = 0;
olist = srealloc(olist, (no+1)*sizeof *olist),
olistf = srealloc(olistf,(no+1)*sizeof *olistf),
olist[no] = 0, olistf[no] = 0,
arg; no++) {
if (arg[0] == '1' && arg[1] == '.') {
olistf[no] = F1;
olist[no] = strtol(&arg[2], &x, 10);
} else if (arg[0] == '2' && arg[1] == '.') {
olist[no] = strtol(&arg[2], &x, 10);
olistf[no] = F2;
} else if (arg[0] == '0') {
olistf[no] = JF;
x = &arg[1];
} else
break;
while (*x == ' ' || *x == ',')
x++;
if (*x)
arg = x;
else {
argc--;
argv++;
arg = argv[2];
}
}
if (no == 0) {
fprintf(stderr, "%s: invalid file number (%s) "
"for -o\n", progname, arg);
exit(2);
}
break;
case 'j':
if (argv[2] == NULL)
usage();
if (argv[1][2] == '1')
j1 = atoi(argv[2]);
else if (argv[1][2] == '2')
j2 = atoi(argv[2]);
else
j1 = j2 = atoi(argv[2]);
argc--;
argv++;
break;
case '1':
if (argv[1][2])
arg = &argv[1][2];
else if (argv[2]) {
arg = argv[2];
argv++, argc--;
} else
usage();
j1 = atoi(arg);
break;
case '2':
if (argv[1][2])
arg = &argv[1][2];
else if (argv[2]) {
arg = argv[2];
argv++, argc--;
} else
usage();
j2 = atoi(arg);
break;
case 'v':
if (argv[1][2])
arg = &argv[1][2];
else if (argv[2]) {
arg = argv[2];
argv++, argc--;
} else
usage();
if (*arg == '1')
vflg |= 1;
else if (*arg == '2')
vflg |= 2;
break;
}
argc--;
argv++;
}
for (i = 0; i < no; i++)
olist[i]--; /* 0 origin */
if (argc != 3)
usage();
j1--;
j2--; /* everyone else believes in 0 origin */
s1 = ppi(F1, j1);
s2 = ppi(F2, j2);
if (argv[1][0] == '-' && argv[1][1] == '\0')
f[F1] = ib_alloc(0, 0);
else if ((f[F1] = ib_open(argv[1], 0)) == NULL)
error("can't open ", argv[1]);
if (argv[2][0] == '-' && argv[2][1] == '\0')
f[F2] = ib_alloc(0, 0);
else if ((f[F2] = ib_open(argv[2], 0)) == NULL)
error("can't open ", argv[2]);
#define get1() n1=input(F1)
#define get2() n2=input(F2)
get1();
bot2 = ib_seek(f[F2], 0, SEEK_CUR);
get2();
while(n1>=0 && n2>=0 || (aflg|vflg)!=0 && (n1>=0||n2>=0)) {
if(n1>=0 && n2>=0 && comp()>0 || n1<0) {
if(aflg&2||vflg&2) output(0, n2);
bot2 = ib_seek(f[F2], 0, SEEK_CUR);
get2();
} else if(n1>=0 && n2>=0 && comp()<0 || n2<0) {
if(aflg&1||vflg&1) output(n1, 0);
get1();
} else { /*(n1>=0 && n2>=0 && comp()==0)*/
while(n2>=0 && comp()==0) {
if(vflg==0) output(n1, n2);
top2 = ib_seek(f[F2], 0, SEEK_CUR);
get2();
}
ib_seek(f[F2], bot2, SEEK_SET);
get2();
get1();
for(;;) {
if(n1>=0 && n2>=0 && comp()==0) {
if(vflg==0) output(n1, n2);
get2();
} else if(n1>=0 && n2>=0 && comp()<0 || n2<0) {
ib_seek(f[F2], bot2, SEEK_SET);
get2();
get1();
} else { /*(n1>=0 && n2>=0 && comp()>0 || n1<0)*/
ib_seek(f[F2], top2, SEEK_SET);
bot2 = top2;
get2();
break;
}
}
}
}
return(0);
}
void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
(
const Pstream::commsTypes,
gpuField<Type>& pField
) const
{
if (cyclicAMIPatch_.cyclicAMIPatch().owner())
{
// We inplace modify pField. To prevent the other side (which gets
// evaluated at a later date) using already changed values we do
// all swaps on the side that gets evaluated first.
// Get neighbouring pointPatch
const cyclicAMIPointPatch& nbrPatch = cyclicAMIPatch_.neighbPatch();
// Get neighbouring pointPatchField
const GeometricField<Type, pointPatchField, pointMesh>& fld =
refCast<const GeometricField<Type, pointPatchField, pointMesh> >
(
this->dimensionedInternalField()
);
const cyclicAMIPointPatchField<Type>& nbr =
refCast<const cyclicAMIPointPatchField<Type> >
(
fld.boundaryField()[nbrPatch.index()]
);
Field<Type> ptFld(this->patchInternalField(pField)().asField());
Field<Type> nbrPtFld(nbr.patchInternalField(pField)().asField());
if (doTransform())
{
const tensor& forwardT = this->forwardT()[0];
const tensor& reverseT = this->reverseT()[0];
transform(ptFld, reverseT, ptFld);
transform(nbrPtFld, forwardT, nbrPtFld);
}
// convert point field to face field, AMI interpolate, then
// face back to point
{
// add neighbour side contribution to owner
Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
// interpolate to owner
if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
{
Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
nbrFcFld =
cyclicAMIPatch_.cyclicAMIPatch().interpolate
(
nbrFcFld,
fcFld
);
}
else
{
nbrFcFld =
cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
}
// add to internal field
this->addToInternalField
(
pField,
gpuField<Type>(ppi().faceToPointInterpolate(nbrFcFld)())
);
}
{
// add owner side contribution to neighbour
Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
// interpolate to neighbour
if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
{
Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
fcFld =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
(
fcFld,
nbrFcFld
);
}
else
{
fcFld =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
(
fcFld
);
}
// add to internal field
nbr.addToInternalField
(
pField,
gpuField<Type>(nbrPpi().faceToPointInterpolate(fcFld)())
);
}
}
}
