contractor mk_contractor_gsl(box const & box, shared_ptr<ode_constraint> const ctr, contractor const & eval_ctc, ode_direction const dir, bool const use_cache, double const timeout) {
if (!use_cache) {
return contractor(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
}
if (dir == ode_direction::FWD) {
static unordered_map<shared_ptr<ode_constraint>, contractor> gsl_fwd_ctc_cache;
auto it = gsl_fwd_ctc_cache.find(ctr);
if (it == gsl_fwd_ctc_cache.end()) {
contractor ctc(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
gsl_fwd_ctc_cache.emplace(ctr, ctc);
return ctc;
} else {
return it->second;
}
} else {
static unordered_map<shared_ptr<ode_constraint>, contractor> gsl_bwd_ctc_cache;
auto it = gsl_bwd_ctc_cache.find(ctr);
if (it == gsl_bwd_ctc_cache.end()) {
contractor ctc(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
gsl_bwd_ctc_cache.emplace(ctr, ctc);
return ctc;
} else {
return it->second;
}
}
}
void ts802_state::ts802(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, 16_MHz_XTAL / 4);
m_maincpu->set_addrmap(AS_PROGRAM, &ts802_state::ts802_mem);
m_maincpu->set_addrmap(AS_IO, &ts802_state::ts802_io);
//m_maincpu->set_daisy_config(daisy_chain_intf); // causes problems
/* Devices */
GENERIC_TERMINAL(config, m_terminal, 0);
m_terminal->set_keyboard_callback(FUNC(ts802_state::kbd_put));
z80dma_device& dma(Z80DMA(config, "dma", 16_MHz_XTAL / 4));
dma.out_busreq_callback().set_inputline(m_maincpu, INPUT_LINE_HALT);
dma.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
dma.in_mreq_callback().set(FUNC(ts802_state::memory_read_byte));
dma.out_mreq_callback().set(FUNC(ts802_state::memory_write_byte));
dma.in_iorq_callback().set(FUNC(ts802_state::io_read_byte));
dma.out_iorq_callback().set(FUNC(ts802_state::io_write_byte));
z80dart_device& dart1(Z80DART(config, "dart1", 16_MHz_XTAL / 4));
dart1.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
z80dart_device& dart2(Z80DART(config, "dart2", 16_MHz_XTAL / 4));
dart2.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
z80ctc_device& ctc(Z80CTC(config, "ctc", 16_MHz_XTAL / 4));
ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
FD1793(config, "fdc", 4'000'000 / 2); // unknown clock
FLOPPY_CONNECTOR(config, "fdc:0", ts802_floppies, "525dd", floppy_image_device::default_floppy_formats).enable_sound(true);
}
void QAniTransferFunctionInstance::load(QFile & file) {
file.read((char *)&m_resolution, 4);
file.read((char *)&m_tfResolutionChange, 4);
m_tfDrawArrayChange = new float[m_resolution];
file.read((char *)m_tfDrawArrayChange, 4 * m_resolution);
int size;
file.read((char *)&size, 4);
for (int i = 0; i < size; ++i) {
double mean,sigma,height;
file.read((char *)&mean, 8);
file.read((char *)&sigma, 8);
file.read((char *)&height, 8);
GaussianObjectChange goc(mean, sigma, height);
m_gaussianObjectChange.push_back(goc);
}
file.read((char *)&size, 4);
for (int i = 0; i < size; ++i) {
float x;
Vector4 color;
file.read((char *)&x, 4);
file.read((char *)((double*)color), 32);
ColorTickChange ctc(x, color);
m_tfColorTickChange.push_back(ctc);
}
}
QAniTransferFunctionInstance::QAniTransferFunctionInstance(QAniKeyframe* s, QAniKeyframe* e) : QAniInstance(QAniInstance::TransferFunction, s, e) {
QAniTransferFunctionKeyframe * start = (QAniTransferFunctionKeyframe*)s;
QAniTransferFunctionKeyframe * end = (QAniTransferFunctionKeyframe*)e;
m_resolution = start->getResolution();
m_tfResolutionChange = end->getResolution() - start->getResolution();
if (m_tfResolutionChange == 0) {
m_tfDrawArrayChange = new float[start->getResolution()];
for (int i = 0; i < start->getResolution(); ++i) {
m_tfDrawArrayChange[i] = end->getDrawArray()[i] - start->getDrawArray()[i];
}
}
else m_tfDrawArrayChange = NULL;
int idx = (start->getGaussians()->size() < end->getGaussians()->size() ?
start->getGaussians()->size() : end->getGaussians()->size());
m_gaussianObjectChange.clear();
for (int i = 0; i < idx; ++i) {
GaussianObjectChange goc((*end->getGaussians())[i].m_mean - (*start->getGaussians())[i].m_mean,
(*end->getGaussians())[i].m_sigma - (*start->getGaussians())[i].m_sigma,
(*end->getGaussians())[i].m_heightFactor - (*start->getGaussians())[i].m_heightFactor);
m_gaussianObjectChange.push_back(goc);
}
idx = (start->getColors()->size() < end->getColors()->size() ?
start->getColors()->size() : end->getColors()->size());
m_tfColorTickChange.clear();
for (int i = 0; i < idx; ++i) {
Vector4 color((*end->getColors())[i].m_color.redF() - (*start->getColors())[i].m_color.redF(),
(*end->getColors())[i].m_color.greenF() - (*start->getColors())[i].m_color.greenF(),
(*end->getColors())[i].m_color.blueF() - (*start->getColors())[i].m_color.blueF(),
(*end->getColors())[i].m_color.alphaF() - (*start->getColors())[i].m_color.alphaF());
ColorTickChange ctc((*end->getColors())[i].m_resX - (*start->getColors())[i].m_resX, color);
m_tfColorTickChange.push_back(ctc);
}
}
void czk80_state::czk80(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, 16_MHz_XTAL / 4);
m_maincpu->set_addrmap(AS_PROGRAM, &czk80_state::czk80_mem);
m_maincpu->set_addrmap(AS_IO, &czk80_state::czk80_io);
m_maincpu->set_daisy_config(daisy_chain);
GENERIC_TERMINAL(config, m_terminal, 0);
m_terminal->set_keyboard_callback(FUNC(czk80_state::kbd_put));
UPD765A(config, m_fdc, 8_MHz_XTAL, true, true);
FLOPPY_CONNECTOR(config, "fdc:0", czk80_floppies, "525dd", floppy_image_device::default_floppy_formats);
z80ctc_device& ctc(Z80CTC(config, "ctc", 16_MHz_XTAL / 4));
ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
ctc.zc_callback<0>().set(FUNC(czk80_state::ctc_z0_w));
ctc.zc_callback<1>().set(FUNC(czk80_state::ctc_z1_w));
ctc.zc_callback<2>().set(FUNC(czk80_state::ctc_z2_w));
z80dart_device& dart(Z80DART(config, "dart", 16_MHz_XTAL / 4));
//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("maincpu", INPUT_LINE_IRQ0);
z80pio_device& pio(Z80PIO(config, "pio", 16_MHz_XTAL / 4));
pio.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
}
/* static */
bool CTC::ComputeCTCTargets(const GenericVector<int>& labels, int null_char,
const GENERIC_2D_ARRAY<float>& outputs,
NetworkIO* targets) {
std::unique_ptr<CTC> ctc(new CTC(labels, null_char, outputs));
if (!ctc->ComputeLabelLimits()) {
return false; // Not enough time.
}
// Generate simple targets purely from the truth labels by spreading them
// evenly over time.
GENERIC_2D_ARRAY<float> simple_targets;
ctc->ComputeSimpleTargets(&simple_targets);
// Add the simple targets as a starter bias to the network outputs.
float bias_fraction = ctc->CalculateBiasFraction();
simple_targets *= bias_fraction;
ctc->outputs_ += simple_targets;
NormalizeProbs(&ctc->outputs_);
// Run regular CTC on the biased outputs.
// Run forward and backward
GENERIC_2D_ARRAY<double> log_alphas, log_betas;
ctc->Forward(&log_alphas);
ctc->Backward(&log_betas);
// Normalize and come out of log space with a clipped softmax over time.
log_alphas += log_betas;
ctc->NormalizeSequence(&log_alphas);
ctc->LabelsToClasses(log_alphas, targets);
NormalizeProbs(targets);
return true;
}
void vdm7932x_state::vdm7932x(machine_config &config) // all clocks unverified
{
Z80(config, m_maincpu, 24.0734_MHz_XTAL / 8); // UA880D
m_maincpu->set_addrmap(AS_PROGRAM, &vdm7932x_state::mem_map);
m_maincpu->set_addrmap(AS_IO, &vdm7932x_state::io_map);
m_maincpu->set_daisy_config(daisy_chain);
I8031(config, m_subcpu, 24.0734_MHz_XTAL / 4); // Intel P8031AH (for keyboard?)
m_subcpu->port_in_cb<3>().set(FUNC(vdm7932x_state::i8031_p3_r));
m_subcpu->set_addrmap(AS_PROGRAM, &vdm7932x_state::sub_map);
m_subcpu->set_addrmap(AS_IO, &vdm7932x_state::subx_map);
PIT8253(config, "pit", 0); // UM8253-5
z80ctc_device &ctc(Z80CTC(config, "ctc", 24.0734_MHz_XTAL / 8)); // UA857D
ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
z80sio_device &sio(Z80SIO(config, "sio", 24.0734_MHz_XTAL / 8)); // UA8560D
sio.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
i8255_device &ppi1(I8255A(config, "ppi1")); // КР580ВВ55А (on separate card)
ppi1.out_pc_callback().set(FUNC(vdm7932x_state::ppi1_pc_w));
I8255A(config, "ppi2"); // КР580ВВ55А (on separate card)
}
contractor mk_contractor_eval(box const & box, nonlinear_constraint const * const ctr) {
static thread_local unordered_map<nonlinear_constraint const *, contractor> cache;
auto const it = cache.find(ctr);
if (it == cache.cend()) {
contractor ctc(make_shared<contractor_eval>(box, ctr));
cache.emplace(ctr, ctc);
return ctc;
} else {
return it->second;
}
}
DefaultSolver::DefaultSolver(System& sys, double prec) : Solver(rec(ctc(sys,prec)),
rec(new SmearSumRelative(sys, prec)),
rec(new CellStack())),
sys(sys) {
srand(1);
data = *memory(); // keep track of my data
*memory() = NULL; // reset (for next DefaultSolver to be created)
}
void TestCtcFwdBwd::atan2_issue134() {
Variable x, y, z;
Function f(y, x, z, z - atan2(y, x));
NumConstraint c(f);
CtcFwdBwd ctc(c);
IntervalVector box(3);
box[0] = Interval(1,1);
box[1] = Interval(0,0);
box[2] = Interval(-100,100);
ctc.contract(box);
check(box[2],Interval::HALF_PI);
}
void TestCtcFwdBwd::sqrt_issue28() {
Variable x;
Function f(x,sqrt(x));
NumConstraint c(f);
CtcFwdBwd ctc(c);
IntervalVector box(1,Interval(-2,-1));
ctc.contract(box);
TEST_ASSERT(box.is_empty());
}
contractor mk_contractor_eval(shared_ptr<nonlinear_constraint> const ctr, bool const use_cache) {
if (!use_cache) {
return contractor(make_shared<contractor_eval>(ctr));
}
static unordered_map<shared_ptr<nonlinear_constraint>, contractor> eval_ctc_cache;
auto const it = eval_ctc_cache.find(ctr);
if (it == eval_ctc_cache.end()) {
contractor ctc(make_shared<contractor_eval>(ctr));
eval_ctc_cache.emplace(ctr, ctc);
return ctc;
} else {
return it->second;
}
}
void a5105_state::a5105(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, XTAL(15'000'000) / 4);
m_maincpu->set_addrmap(AS_PROGRAM, &a5105_state::a5105_mem);
m_maincpu->set_addrmap(AS_IO, &a5105_state::a5105_io);
m_maincpu->set_daisy_config(a5105_daisy_chain);
/* video hardware */
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(50);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
m_screen->set_screen_update("upd7220", FUNC(upd7220_device::screen_update));
m_screen->set_size(40*8, 32*8);
m_screen->set_visarea(0, 40*8-1, 0, 25*8-1);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_a5105);
PALETTE(config, m_palette, FUNC(a5105_state::a5105_palette), 16);
/* sound hardware */
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
BEEP(config, "beeper", 500).add_route(ALL_OUTPUTS, "mono", 0.50);
/* Devices */
UPD7220(config, m_hgdc, XTAL(15'000'000) / 16); // unk clock
m_hgdc->set_addrmap(0, &a5105_state::upd7220_map);
m_hgdc->set_display_pixels(FUNC(a5105_state::hgdc_display_pixels));
m_hgdc->set_draw_text(FUNC(a5105_state::hgdc_draw_text));
z80ctc_device& ctc(Z80CTC(config, "z80ctc", XTAL(15'000'000) / 4));
ctc.intr_callback().set_inputline(m_maincpu, 0);
ctc.zc_callback<0>().set("z80ctc", FUNC(z80ctc_device::trg2));
ctc.zc_callback<2>().set("z80ctc", FUNC(z80ctc_device::trg3));
z80pio_device& pio(Z80PIO(config, "z80pio", XTAL(15'000'000) / 4));
pio.in_pb_callback().set(FUNC(a5105_state::pio_pb_r));
pio.out_int_callback().set_inputline(m_maincpu, 0);
CASSETTE(config, m_cass);
UPD765A(config, m_fdc, 8'000'000, true, true);
FLOPPY_CONNECTOR(config, "upd765a:0", a5105_floppies, "525qd", a5105_state::floppy_formats);
FLOPPY_CONNECTOR(config, "upd765a:1", a5105_floppies, "525qd", a5105_state::floppy_formats);
FLOPPY_CONNECTOR(config, "upd765a:2", a5105_floppies, "525qd", a5105_state::floppy_formats);
FLOPPY_CONNECTOR(config, "upd765a:3", a5105_floppies, "525qd", a5105_state::floppy_formats);
/* internal ram */
RAM(config, RAM_TAG).set_default_size("64K");
}
// Note: we set the precision for Newton to the minimum of the precisions.
DefaultSolver::DefaultSolver(System& sys, const Vector& eps_x_min, double eps_x_max, double random_seed) : Solver(sys, rec(ctc(sys,eps_x_min.min())),
get_square_eq_sys(sys)!=NULL?
rec(new SmearSumRelative(*get_square_eq_sys(sys), eps_x_min)) :
rec(new RoundRobin(eps_x_min)),
rec(new CellStack()), eps_x_min, Vector(sys.nb_var,eps_x_max)),
sys(sys) {
RNG::srand(random_seed);
data = *memory(); // keep track of my data
*memory() = NULL; // reset (for next DefaultSolver to be created)
square_eq_system = -1;
}
void pve500_state::pve500(machine_config &config)
{
/* Main CPU */
TMPZ84C015(config, m_maincpu, 12_MHz_XTAL / 2); // TMPZ84C015BF-6
m_maincpu->set_addrmap(AS_PROGRAM, &pve500_state::maincpu_prg);
m_maincpu->set_addrmap(AS_IO, &pve500_state::maincpu_io);
m_maincpu->set_daisy_config(maincpu_daisy_chain);
m_maincpu->out_dtra_callback().set(FUNC(pve500_state::GPI_w));
m_maincpu->out_dtrb_callback().set(m_buzzer, FUNC(beep_device::set_state)).invert();
m_maincpu->out_txda_callback().set("recorder", FUNC(rs232_port_device::write_txd));
m_maincpu->out_txdb_callback().set("player1", FUNC(rs232_port_device::write_txd));
z80ctc_device& ctc(Z80CTC(config, "external_ctc", 12_MHz_XTAL / 2));
ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
z80sio0_device& sio(Z80SIO0(config, "external_sio", 12_MHz_XTAL / 2));
sio.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
sio.out_txda_callback().set("player2", FUNC(rs232_port_device::write_txd));
sio.out_txdb_callback().set("edl_inout", FUNC(rs232_port_device::write_txd));
/* Secondary CPU */
TMPZ84C015(config, m_subcpu, 12_MHz_XTAL / 2); /* TMPZ84C015BF-6 */
m_subcpu->set_addrmap(AS_PROGRAM, &pve500_state::subcpu_prg);
m_subcpu->set_addrmap(AS_IO, &pve500_state::subcpu_io);
m_subcpu->out_dtra_callback().set(FUNC(pve500_state::cxdio_reset_w));
m_subcpu->out_dtrb_callback().set(FUNC(pve500_state::external_monitor_w));
m_subcpu->out_txda_callback().set("switcher", FUNC(rs232_port_device::write_txd));
m_subcpu->out_txdb_callback().set("serial_mixer", FUNC(rs232_port_device::write_txd));
// PIO callbacks
m_subcpu->in_pa_callback().set(FUNC(pve500_state::eeprom_r));
m_subcpu->out_pa_callback().set(FUNC(pve500_state::eeprom_w));
// ICG3: I/O Expander
CXD1095(config, m_cxdio, 0);
m_cxdio->out_porta_cb().set(FUNC(pve500_state::io_sc_w));
m_cxdio->out_portb_cb().set(FUNC(pve500_state::io_le_w));
m_cxdio->in_portc_cb().set(FUNC(pve500_state::io_ky_r));
m_cxdio->out_portd_cb().set(FUNC(pve500_state::io_ld_w));
m_cxdio->out_porte_cb().set(FUNC(pve500_state::io_sel_w));
/* Search Dial MCUs */
MB88201(config, "dial_mcu_left", 4_MHz_XTAL).set_disable(); /* PLAYER DIAL MCU */
MB88201(config, "dial_mcu_right", 4_MHz_XTAL).set_disable(); /* RECORDER DIAL MCU */
/* Serial EEPROM (128 bytes, 8-bit data organization) */
/* The EEPROM stores the setup data */
EEPROM_MSM16911_8BIT(config, "eeprom");
/* FIX-ME: These are actually RS422 ports (except EDL IN/OUT which is indeed an RS232 port)*/
rs232_port_device &recorder(RS232_PORT(config, "recorder", default_rs232_devices, nullptr));
recorder.rxd_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxa_w));
rs232_port_device &player1(RS232_PORT(config, "player1", default_rs232_devices, nullptr));
player1.rxd_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxb_w));
rs232_port_device &player2(RS232_PORT(config, "player2", default_rs232_devices, nullptr));
player2.rxd_handler().set("external_sio", FUNC(z80dart_device::rxa_w));
rs232_port_device &edl_inout(RS232_PORT(config, "edl_inout", default_rs232_devices, nullptr));
edl_inout.rxd_handler().set("external_sio", FUNC(z80dart_device::rxb_w));
rs232_port_device &switcher(RS232_PORT(config, "switcher", default_rs232_devices, nullptr));
switcher.rxd_handler().set(m_subcpu, FUNC(tmpz84c015_device::rxa_w));
rs232_port_device &serial_mixer(RS232_PORT(config, "serial_mixer", default_rs232_devices, nullptr));
serial_mixer.rxd_handler().set(m_subcpu, FUNC(tmpz84c015_device::rxb_w));
clock_device &clk1(CLOCK(config, "clk1", 12_MHz_XTAL / 20));
clk1.signal_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxca_w));
clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::txca_w));
clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::rxcb_w));
clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::txcb_w));
clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::rxca_w));
clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::txca_w));
clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::rxcb_w));
clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::txcb_w));
/* ICF5: 2kbytes of RAM shared between the two CPUs (dual-port RAM)*/
mb8421_device &mb8421(MB8421(config, "mb8421"));
mb8421.intl_callback().set(FUNC(pve500_state::mb8421_intl));
mb8421.intr_callback().set(FUNC(pve500_state::mb8421_intr));
/* video hardware */
config.set_default_layout(layout_pve500);
/* audio hardware */
SPEAKER(config, "mono").front_center();
BEEP(config, "buzzer", 12_MHz_XTAL / 3200).add_route(ALL_OUTPUTS, "mono", 0.05); // 3.75 kHz CLK2 coming out of IC D4 (frequency divider circuitry)
}
