Previous

199869 Revisions

Next

r34471 Sunday 18th January, 2015 at 19:13:11 UTC by Luca Bruno
core: link state entries to parent state interface In device state, link a single device_state_entry to its parent device_state_interface and expose a parent_state() getter. Signed-off-by: Luca Bruno <lucab@debian.org>

[src/emu]	distate.c distate.h
[src/emu/machine]	netlist.c
[src/emu/netlist]	nl_base.c nl_base.h nl_config.h nl_dice_compat.h nl_factory.c nl_factory.h nl_parser.c nl_parser.h nl_setup.c nl_setup.h pstate.c pstate.h pstring.c pstring.h
[src/emu/netlist/analog]	nld_bjt.c nld_bjt.h nld_fourterm.c nld_fourterm.h nld_ms_direct.h nld_ms_direct1.h nld_ms_direct2.h nld_ms_gauss_seidel.h nld_solver.c nld_solver.h nld_twoterm.c nld_twoterm.h
[src/emu/netlist/devices]	nld_4020.c nld_4066.c nld_74123.c nld_74ls629.c nld_cmos.h nld_ne555.c nld_ne555.h nld_r2r_dac.c nld_system.c
[src/mame/drivers]	nl_pongd.c
[src/tools]	nltool.c

trunk/src/emu/distate.c

r242982	r242983
49	49	//  device_state_entry - constructor
50	50	//-------------------------------------------------
51	51
52		device_state_entry::device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size)
53		: m_next(NULL),
	52	device_state_entry::device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size, device_state_interface *dev)
	53	: m_device_state(dev),
	54	m_next(NULL),
54	55	m_index(index),
55	56	m_dataptr(dataptr),
56	57	m_datamask(0),
r242982	r242983
86	87	m_symbol.cpy("CURFLAGS");
87	88	}
88	89
89		device_state_entry::device_state_entry(int index)
90		: m_next(NULL),
	90	device_state_entry::device_state_entry(int index, device_state_interface *dev)
	91	: m_device_state(dev),
	92	m_next(NULL),
91	93	m_index(index),
92	94	m_dataptr(NULL),
93	95	m_datamask(0),
r242982	r242983
523	525	assert(symbol != NULL);
524	526
525	527	// allocate new entry
526		device_state_entry *entry = global_alloc(device_state_entry(index, symbol, data, size));
	528	device_state_entry *entry = global_alloc(device_state_entry(index, symbol, data, size, this));
527	529
528	530	// append to the end of the list
529	531	m_state_list.append(*entry);
r242982	r242983
543	545	device_state_entry &device_state_interface::state_add_divider(int index)
544	546	{
545	547	// allocate new entry
546		device_state_entry *entry = global_alloc(device_state_entry(index));
	548	device_state_entry *entry = global_alloc(device_state_entry(index, this));
547	549
548	550	// append to the end of the list
549	551	m_state_list.append(*entry);

trunk/src/emu/distate.h

r242982	r242983
49	49
50	50	private:
51	51	// construction/destruction
52		device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size);
53		device_state_entry(int index);
	52	device_state_entry(int index, const char *symbol, void *dataptr, UINT8 size, device_state_interface *dev);
	53	device_state_entry(int index, device_state_interface *dev);
54	54
55	55	public:
56	56	// post-construction modifiers
r242982	r242983
70	70	const char *symbol() const { return m_symbol; }
71	71	bool visible() const { return ((m_flags & DSF_NOSHOW) == 0); }
72	72	bool divider() const { return m_flags & DSF_DIVIDER; }
	73	device_state_interface *parent_state() const {return m_device_state;}
73	74
74	75	protected:
75	76	// device state flags
r242982	r242983
98	99	static const UINT64 k_decimal_divisor[20];      // divisors for outputting decimal values
99	100
100	101	// public state description
	102	device_state_interface *m_device_state;         // link to parent device state
101	103	device_state_entry *    m_next;                 // link to next item
102	104	UINT32                  m_index;                // index by which this item is referred
103	105	generic_ptr             m_dataptr;              // pointer to where the data lives

trunk/src/emu/machine/netlist.c

r242982	r242983
48	48	#include "netlist.h"
49	49	#include "netlist/nl_base.h"
50	50	#include "netlist/nl_setup.h"
51		#include "netlist/nl_factory.h"
52	51	#include "netlist/devices/net_lib.h"
53	52	#include "debugger.h"
54	53
r242982	r242983
135	134	pstring dname = "OUT_" + m_in;
136	135	m_delegate.bind_relative_to(owner()->machine().root_device());
137	136	NETLIB_NAME(analog_callback) *dev = downcast<NETLIB_NAME(analog_callback) *>(
138		setup.register_dev("nld_analog_callback", dname));
	137	setup.factory().new_device_by_classname("nld_analog_callback", setup));
139	138
	139	setup.register_dev(dev, dname);
140	140	dev->register_callback(m_delegate);
141	141	setup.register_link(dname + ".IN", m_in);
142	142	}
r242982	r242983
208	208	{
209	209	NETLIB_NAME(sound_in) *snd_in = setup.netlist().get_first_device<NETLIB_NAME(sound_in)>();
210	210	if (snd_in == NULL)
211		snd_in = dynamic_cast<NETLIB_NAME(sound_in) *>(setup.register_dev("nld_sound_in", "STREAM_INPUT"));
	211	{
	212	snd_in = dynamic_cast<NETLIB_NAME(sound_in) *>(setup.factory().new_device_by_classname("nld_sound_in", setup));
	213	setup.register_dev(snd_in, "STREAM_INPUT");
	214	}
212	215
213	216	pstring sparam = pstring::sprintf("STREAM_INPUT.CHAN%d", m_channel);
214	217	setup.register_param(sparam, m_param_name);
r242982	r242983
244	247
245	248	void netlist_mame_stream_output_t::custom_netlist_additions(netlist_setup_t &setup)
246	249	{
247		//NETLIB_NAME(sound_out) *snd_out;
	250	NETLIB_NAME(sound_out) *snd_out;
248	251	pstring sname = pstring::sprintf("STREAM_OUT_%d", m_channel);
249	252
250		//snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.register_dev("nld_sound_out", sname));
251		setup.register_dev("nld_sound_out", sname);
	253	snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.factory().new_device_by_classname("nld_sound_out", setup));
	254	setup.register_dev(snd_out, sname);
252	255
253	256	setup.register_param(sname + ".CHAN" , m_channel);
254	257	setup.register_param(sname + ".MULT",  m_mult);
r242982	r242983
440	443	if (td != NULL) save_pointer(td, s->m_name, s->m_count);
441	444	}
442	445	break;
443		case DT_FLOAT:
444		{
445		float *td = s->resolved<float>();
446		if (td != NULL) save_pointer(td, s->m_name, s->m_count);
447		}
448		break;
449	446	case DT_INT64:
450	447	save_pointer((INT64 *) s->m_ptr, s->m_name, s->m_count);
451	448	break;

trunk/src/emu/netlist/analog/nld_bjt.c

r242982	r242983
11	11	{
12	12	public:
13	13	diode() : m_Is(1e-15), m_VT(0.0258), m_VT_inv(1.0 / m_VT) {}
14		diode(const nl_double Is, const nl_double n)
	14	diode(const double Is, const double n)
15	15	{
16	16	m_Is = Is;
17	17	m_VT = 0.0258 * n;
18	18	m_VT_inv = 1.0 / m_VT;
19	19	}
20		void set(const nl_double Is, const nl_double n)
	20	void set(const double Is, const double n)
21	21	{
22	22	m_Is = Is;
23	23	m_VT = 0.0258 * n;
24	24	m_VT_inv = 1.0 / m_VT;
25	25	}
26		nl_double I(const nl_double V) const { return m_Is * exp(V * m_VT_inv) - m_Is; }
27		nl_double g(const nl_double V) const { return m_Is * m_VT_inv * exp(V * m_VT_inv); }
28		nl_double V(const nl_double I) const { return log(1.0 + I / m_Is) * m_VT; }
29		nl_double gI(const nl_double I) const { return m_VT_inv * (I + m_Is); }
	26	double I(const double V) const { return m_Is * exp(V * m_VT_inv) - m_Is; }
	27	double g(const double V) const { return m_Is * m_VT_inv * exp(V * m_VT_inv); }
	28	double V(const double I) const { return log(1.0 + I / m_Is) * m_VT; }
	29	double gI(const double I) const { return m_VT_inv * (I + m_Is); }
30	30
31	31	private:
32		nl_double m_Is;
33		nl_double m_VT;
34		nl_double m_VT_inv;
	32	double m_Is;
	33	double m_VT;
	34	double m_VT_inv;
35	35	};
36	36
37	37
r242982	r242983
85	85	m_state_on = 0;
86	86
87	87	{
88		nl_double IS = m_model.model_value("IS", 1e-15);
89		nl_double BF = m_model.model_value("BF", 100);
90		nl_double NF = m_model.model_value("NF", 1);
91		//nl_double VJE = m_model.dValue("VJE", 0.75);
	88	double IS = m_model.model_value("IS", 1e-15);
	89	double BF = m_model.model_value("BF", 100);
	90	double NF = m_model.model_value("NF", 1);
	91	//double VJE = m_model.dValue("VJE", 0.75);
92	92
93	93	set_qtype((m_model.model_type() == "NPN") ? BJT_NPN : BJT_PNP);
94	94
95		nl_double alpha = BF / (1.0 + BF);
	95	double alpha = BF / (1.0 + BF);
96	96
97	97	diode d(IS, NF);
98	98
r242982	r242983
155	155	m_gD_BC.save("m_D_BC", *this);
156	156
157	157	{
158		nl_double IS = m_model.model_value("IS", 1e-15);
159		nl_double BF = m_model.model_value("BF", 100);
160		nl_double NF = m_model.model_value("NF", 1);
161		nl_double BR = m_model.model_value("BR", 1);
162		nl_double NR = m_model.model_value("NR", 1);
163		//nl_double VJE = m_model.dValue("VJE", 0.75);
	158	double IS = m_model.model_value("IS", 1e-15);
	159	double BF = m_model.model_value("BF", 100);
	160	double NF = m_model.model_value("NF", 1);
	161	double BR = m_model.model_value("BR", 1);
	162	double NR = m_model.model_value("NR", 1);
	163	//double VJE = m_model.dValue("VJE", 0.75);
164	164
165	165	set_qtype((m_model.model_type() == "NPN") ? BJT_NPN : BJT_PNP);
166	166	//printf("type %s\n", m_model.model_type().cstr());

trunk/src/emu/netlist/analog/nld_bjt.h

r242982	r242983
98	98
99	99	NETLIB_UPDATE_TERMINALS()
100	100	{
101		const nl_double m = (is_qtype( BJT_NPN) ? 1 : -1);
	101	const double m = (is_qtype( BJT_NPN) ? 1 : -1);
102	102
103	103	const int new_state = (m_RB.deltaV() * m > m_V ) ? 1 : 0;
104	104	if (m_state_on ^ new_state)
105	105	{
106	106	#if 0
107		nl_double gb = m_gB;
108		nl_double gc = m_gC;
109		nl_double v  = m_V * m;
	107	double gb = m_gB;
	108	double gc = m_gC;
	109	double v  = m_V * m;
110	110	if (!new_state )
111	111	{
112	112	// not conducting
r242982	r242983
115	115	gc = netlist().gmin();
116	116	}
117	117	#else
118		const nl_double gb = new_state ? m_gB : netlist().gmin();
119		const nl_double gc = new_state ? m_gC : netlist().gmin();
120		const nl_double v  = new_state ? m_V * m : 0;
	118	const double gb = new_state ? m_gB : netlist().gmin();
	119	const double gc = new_state ? m_gC : netlist().gmin();
	120	const double v  = new_state ? m_V * m : 0;
121	121	#endif
122	122	m_RB.set(gb, v,   0.0);
123	123	m_RC.set(gc, 0.0, 0.0);
r242982	r242983
142	142	ATTR_COLD virtual void start();
143	143	ATTR_HOT void update_param();
144	144
145		nl_double m_gB; // base conductance / switch on
146		nl_double m_gC; // collector conductance / switch on
147		nl_double m_V; // internal voltage source
	145	double m_gB; // base conductance / switch on
	146	double m_gC; // collector conductance / switch on
	147	double m_V; // internal voltage source
148	148	UINT8 m_state_on;
149	149
150	150	private:
r242982	r242983
169	169
170	170	NETLIB_UPDATE_TERMINALS()
171	171	{
172		const nl_double polarity = (qtype() == BJT_NPN ? 1.0 : -1.0);
	172	const double polarity = (qtype() == BJT_NPN ? 1.0 : -1.0);
173	173
174	174	m_gD_BE.update_diode(-m_D_EB.deltaV() * polarity);
175	175	m_gD_BC.update_diode(-m_D_CB.deltaV() * polarity);
176	176
177		const nl_double gee = m_gD_BE.G();
178		const nl_double gcc = m_gD_BC.G();
179		const nl_double gec =  m_alpha_r * gcc;
180		const nl_double gce =  m_alpha_f * gee;
181		const nl_double sIe = -m_gD_BE.I() + m_alpha_r * m_gD_BC.I();
182		const nl_double sIc = m_alpha_f * m_gD_BE.I() - m_gD_BC.I();
183		const nl_double Ie = (sIe + gee * m_gD_BE.Vd() - gec * m_gD_BC.Vd()) * polarity;
184		const nl_double Ic = (sIc - gce * m_gD_BE.Vd() + gcc * m_gD_BC.Vd()) * polarity;
	177	const double gee = m_gD_BE.G();
	178	const double gcc = m_gD_BC.G();
	179	const double gec =  m_alpha_r * gcc;
	180	const double gce =  m_alpha_f * gee;
	181	const double sIe = -m_gD_BE.I() + m_alpha_r * m_gD_BC.I();
	182	const double sIc = m_alpha_f * m_gD_BE.I() - m_gD_BC.I();
	183	const double Ie = (sIe + gee * m_gD_BE.Vd() - gec * m_gD_BC.Vd()) * polarity;
	184	const double Ic = (sIc - gce * m_gD_BE.Vd() + gcc * m_gD_BC.Vd()) * polarity;
185	185
186	186	m_D_EB.set_mat(gee, gec - gee, gce - gee, gee - gec, Ie, -Ie);
187	187	m_D_CB.set_mat(gcc, gce - gcc, gec - gcc, gcc - gce, Ic, -Ic);
r242982	r242983
202	202	nld_twoterm m_D_EB;  // gee, gec - gee, gce - gee, gee - gec | Ie
203	203	nld_twoterm m_D_EC;  // 0, -gec, -gcc, 0 | 0
204	204
205		nl_double m_alpha_f;
206		nl_double m_alpha_r;
	205	double m_alpha_f;
	206	double m_alpha_r;
207	207
208	208	private:
209	209	};

trunk/src/emu/netlist/analog/nld_fourterm.c

r242982	r242983
17	17	m_gfac = 1.0;
18	18	}
19	19
20		void NETLIB_NAME(VCCS)::start_internal(const nl_double def_RI)
	20	void NETLIB_NAME(VCCS)::start_internal(const double def_RI)
21	21	{
22	22	register_param("G", m_G, 1.0);
23	23	register_param("RI", m_RI, def_RI);
r242982	r242983
45	45
46	46	NETLIB_RESET(VCCS)
47	47	{
48		const nl_double m_mult = m_G.Value() * m_gfac; // 1.0 ==> 1V ==> 1A
49		const nl_double GI = 1.0 / m_RI.Value();
	48	const double m_mult = m_G.Value() * m_gfac; // 1.0 ==> 1V ==> 1A
	49	const double GI = 1.0 / m_RI.Value();
50	50
51	51	m_IP.set(GI);
52	52	m_IN.set(GI);

trunk/src/emu/netlist/analog/nld_fourterm.h

r242982	r242983
59	59	ATTR_COLD virtual void update_param();
60	60	ATTR_HOT ATTR_ALIGN void update();
61	61
62		ATTR_COLD void start_internal(const nl_double def_RI);
	62	ATTR_COLD void start_internal(const double def_RI);
63	63
64	64	netlist_terminal_t m_OP;
65	65	netlist_terminal_t m_ON;
r242982	r242983
73	73	netlist_param_double_t m_G;
74	74	netlist_param_double_t m_RI;
75	75
76		nl_double m_gfac;
	76	double m_gfac;
77	77	};
78	78
79	79	// ----------------------------------------------------------------------------------------
r242982	r242983
115	115	ATTR_COLD virtual void update_param();
116	116	ATTR_HOT ATTR_ALIGN void update();
117	117
118		nl_double m_gfac;
	118	double m_gfac;
119	119	};
120	120
121	121

trunk/src/emu/netlist/analog/nld_ms_direct.h

r242982	r242983
28	28	protected:
29	29	ATTR_COLD virtual void add_term(int net_idx, netlist_terminal_t *term);
30	30
31		ATTR_HOT virtual nl_double vsolve();
	31	ATTR_HOT virtual double vsolve();
32	32
33	33	ATTR_HOT int solve_non_dynamic();
34	34	ATTR_HOT void build_LE();
35		ATTR_HOT void gauss_LE(nl_double (* RESTRICT x));
36		ATTR_HOT nl_double delta(const nl_double (* RESTRICT V));
37		ATTR_HOT void store(const nl_double (* RESTRICT V), const bool store_RHS);
	35	ATTR_HOT void gauss_LE(double (* RESTRICT x));
	36	ATTR_HOT double delta(const double (* RESTRICT V));
	37	ATTR_HOT void store(const double (* RESTRICT V), const bool store_RHS);
38	38
39	39	/* bring the whole system to the current time
40	40	* Don't schedule a new calculation time. The recalculation has to be
41	41	* triggered by the caller after the netlist element was changed.
42	42	*/
43		ATTR_HOT nl_double compute_next_timestep();
	43	ATTR_HOT double compute_next_timestep();
44	44
45		nl_double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
46		nl_double m_RHS[_storage_N];
47		nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
48		nl_double m_Vdelta[_storage_N];
49		nl_double m_last_V[_storage_N];
	45	double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
	46	double m_RHS[_storage_N];
	47	double m_last_RHS[_storage_N]; // right hand side - contains currents
	48	double m_Vdelta[_storage_N];
	49	double m_last_V[_storage_N];
50	50
51	51	terms_t **m_terms;
52	52	terms_t *m_rails_temp;
r242982	r242983
55	55	vector_ops_t *m_row_ops[_storage_N + 1];
56	56
57	57	int m_dim;
58		nl_double m_lp_fact;
	58	double m_lp_fact;
59	59	};
60	60
61	61	// ----------------------------------------------------------------------------------------
r242982	r242983
84	84	}
85	85
86	86	template <int m_N, int _storage_N>
87		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
	87	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
88	88	{
89		nl_double new_solver_timestep = m_params.m_max_timestep;
	89	double new_solver_timestep = m_params.m_max_timestep;
90	90
91	91	if (m_params.m_dynamic)
92	92	{
r242982	r242983
103	103	{
104	104	netlist_analog_net_t *n = m_nets[k];
105	105	#endif
106		const nl_double DD_n = (n->m_cur_Analog - m_last_V[k]);
107		const nl_double hn = current_timestep();
	106	const double DD_n = (n->m_cur_Analog - m_last_V[k]);
	107	const double hn = current_timestep();
108	108
109		nl_double DD2 = (DD_n / hn - n->m_DD_n_m_1 / n->m_h_n_m_1) / (hn + n->m_h_n_m_1);
110		nl_double new_net_timestep;
	109	double DD2 = (DD_n / hn - n->m_DD_n_m_1 / n->m_h_n_m_1) / (hn + n->m_h_n_m_1);
	110	double new_net_timestep;
111	111
112	112	n->m_h_n_m_1 = hn;
113	113	n->m_DD_n_m_1 = DD_n;
r242982	r242983
236	236	for (int i=0; i < N(); i++)
237	237	m_A[k][i] = 0.0;
238	238
239		nl_double rhsk = 0.0;
240		nl_double akk  = 0.0;
	239	double rhsk = 0.0;
	240	double akk  = 0.0;
241	241	{
242	242	const int terms_count = m_terms[k]->count();
243		const nl_double * RESTRICT gt = m_terms[k]->gt();
244		const nl_double * RESTRICT go = m_terms[k]->go();
245		const nl_double * RESTRICT Idr = m_terms[k]->Idr();
	243	const double * RESTRICT gt = m_terms[k]->gt();
	244	const double * RESTRICT go = m_terms[k]->go();
	245	const double * RESTRICT Idr = m_terms[k]->Idr();
246	246	#if VECTALT
247	247
248	248	for (int i = 0; i < terms_count; i++)
r242982	r242983
253	253	#else
254	254	m_terms[k]->ops()->sum2(Idr, gt, rhsk, akk);
255	255	#endif
256		nl_double * const * RESTRICT other_cur_analog = m_terms[k]->other_curanalog();
	256	double * const * RESTRICT other_cur_analog = m_terms[k]->other_curanalog();
257	257	for (int i = m_terms[k]->m_railstart; i < terms_count; i++)
258	258	{
259	259	//rhsk = rhsk + go[i] * terms[i]->m_otherterm->net().as_analog().Q_Analog();
r242982	r242983
272	272	m_A[k][k] += 1.0;
273	273	{
274	274	const int *net_other = m_terms[k]->net_other();
275		const nl_double *go = m_terms[k]->go();
	275	const double *go = m_terms[k]->go();
276	276	const int railstart =  m_terms[k]->m_railstart;
277	277
278	278	for (int i = 0; i < railstart; i++)
r242982	r242983
285	285	m_A[k][k] += akk;
286	286	{
287	287	const int * RESTRICT net_other = m_terms[k]->net_other();
288		const nl_double * RESTRICT go = m_terms[k]->go();
	288	const double * RESTRICT go = m_terms[k]->go();
289	289	const int railstart =  m_terms[k]->m_railstart;
290	290
291	291	for (int i = 0; i < railstart; i++)
r242982	r242983
299	299
300	300	template <int m_N, int _storage_N>
301	301	ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
302		nl_double (* RESTRICT x))
	302	double (* RESTRICT x))
303	303	{
304	304	#if 0
305	305	for (int i = 0; i < N(); i++)
r242982	r242983
336	336	}
337	337
338	338	/* FIXME: Singular matrix? */
339		const nl_double f = 1.0 / m_A[i][i];
	339	const double f = 1.0 / m_A[i][i];
340	340
341	341	/* Eliminate column i from row j */
342	342
343	343	for (int j = i + 1; j < kN; j++)
344	344	{
345		const nl_double f1 = - m_A[j][i] * f;
	345	const double f1 = - m_A[j][i] * f;
346	346	if (f1 != 0.0)
347	347	{
348	348	#if 0 && VECTALT
r242982	r242983
359	359	/* back substitution */
360	360	for (int j = kN - 1; j >= 0; j--)
361	361	{
362		nl_double tmp = 0;
	362	double tmp = 0;
363	363
364	364	for (int k = j + 1; k < kN; k++)
365	365	tmp += m_A[j][k] * x[k];
r242982	r242983
380	380	}
381	381
382	382	template <int m_N, int _storage_N>
383		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
384		const nl_double (* RESTRICT V))
	383	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
	384	const double (* RESTRICT V))
385	385	{
386		nl_double cerr = 0;
387		nl_double cerr2 = 0;
	386	double cerr = 0;
	387	double cerr2 = 0;
388	388	for (int i = 0; i < this->N(); i++)
389	389	{
390		const nl_double e = (V[i] - this->m_nets[i]->m_cur_Analog);
391		const nl_double e2 = (m_RHS[i] - this->m_last_RHS[i]);
	390	const double e = (V[i] - this->m_nets[i]->m_cur_Analog);
	391	const double e2 = (m_RHS[i] - this->m_last_RHS[i]);
392	392	cerr = (fabs(e) > cerr ? fabs(e) : cerr);
393	393	cerr2 = (fabs(e2) > cerr2 ? fabs(e2) : cerr2);
394	394	}
r242982	r242983
398	398
399	399	template <int m_N, int _storage_N>
400	400	ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::store(
401		const nl_double (* RESTRICT V), const bool store_RHS)
	401	const double (* RESTRICT V), const bool store_RHS)
402	402	{
403	403	for (int i = 0; i < this->N(); i++)
404	404	{
r242982	r242983
414	414	}
415	415
416	416	template <int m_N, int _storage_N>
417		ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::vsolve()
	417	ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::vsolve()
418	418	{
419	419	solve_base<netlist_matrix_solver_direct_t>(this);
420	420	return this->compute_next_timestep();
r242982	r242983
424	424	template <int m_N, int _storage_N>
425	425	ATTR_HOT int netlist_matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic()
426	426	{
427		nl_double new_v[_storage_N] = { 0.0 };
	427	double new_v[_storage_N] = { 0.0 };
428	428
429	429	this->gauss_LE(new_v);
430	430
431	431	if (this->is_dynamic())
432	432	{
433		nl_double err = delta(new_v);
	433	double err = delta(new_v);
434	434
435	435	store(new_v, true);
436	436

trunk/src/emu/netlist/analog/nld_ms_direct1.h

r242982	r242983
18	18	{}
19	19	ATTR_HOT inline int vsolve_non_dynamic();
20	20	protected:
21		ATTR_HOT virtual nl_double vsolve();
	21	ATTR_HOT virtual double vsolve();
22	22	private:
23	23	};
24	24
r242982	r242983
26	26	// netlist_matrix_solver - Direct1
27	27	// ----------------------------------------------------------------------------------------
28	28
29		ATTR_HOT nl_double netlist_matrix_solver_direct1_t::vsolve()
	29	ATTR_HOT double netlist_matrix_solver_direct1_t::vsolve()
30	30	{
31	31	solve_base<netlist_matrix_solver_direct1_t>(this);
32	32	return this->compute_next_timestep();
r242982	r242983
38	38	this->build_LE();
39	39	//NL_VERBOSE_OUT(("%f %f\n", new_val, m_RHS[0] / m_A[0][0]);
40	40
41		nl_double new_val =  m_RHS[0] / m_A[0][0];
	41	double new_val =  m_RHS[0] / m_A[0][0];
42	42
43		nl_double e = (new_val - net->m_cur_Analog);
44		nl_double cerr = fabs(e);
	43	double e = (new_val - net->m_cur_Analog);
	44	double cerr = fabs(e);
45	45
46	46	net->m_cur_Analog = new_val;
47	47

trunk/src/emu/netlist/analog/nld_ms_direct2.h

r242982	r242983
20	20	{}
21	21	ATTR_HOT inline int vsolve_non_dynamic();
22	22	protected:
23		ATTR_HOT virtual nl_double vsolve();
	23	ATTR_HOT virtual double vsolve();
24	24	private:
25	25	};
26	26
r242982	r242983
28	28	// netlist_matrix_solver - Direct2
29	29	// ----------------------------------------------------------------------------------------
30	30
31		ATTR_HOT nl_double netlist_matrix_solver_direct2_t::vsolve()
	31	ATTR_HOT double netlist_matrix_solver_direct2_t::vsolve()
32	32	{
33	33	solve_base<netlist_matrix_solver_direct2_t>(this);
34	34	return this->compute_next_timestep();
r242982	r242983
38	38	{
39	39	build_LE();
40	40
41		const nl_double a = m_A[0][0];
42		const nl_double b = m_A[0][1];
43		const nl_double c = m_A[1][0];
44		const nl_double d = m_A[1][1];
	41	const double a = m_A[0][0];
	42	const double b = m_A[0][1];
	43	const double c = m_A[1][0];
	44	const double d = m_A[1][1];
45	45
46		nl_double new_val[2];
	46	double new_val[2];
47	47	new_val[1] = (a * m_RHS[1] - c * m_RHS[0]) / (a * d - b * c);
48	48	new_val[0] = (m_RHS[0] - b * new_val[1]) / a;
49	49
50	50	if (is_dynamic())
51	51	{
52		nl_double err = this->delta(new_val);
	52	double err = this->delta(new_val);
53	53	store(new_val, true);
54	54	if (err > m_params.m_accuracy )
55	55	return 2;

trunk/src/emu/netlist/analog/nld_ms_gauss_seidel.h

r242982	r242983
29	29
30	30	ATTR_HOT inline int vsolve_non_dynamic();
31	31	protected:
32		ATTR_HOT virtual nl_double vsolve();
	32	ATTR_HOT virtual double vsolve();
33	33
34	34	private:
35		nl_double m_lp_fact;
	35	double m_lp_fact;
36	36	int m_gs_fail;
37	37	int m_gs_total;
38	38
r242982	r242983
64	64	}
65	65
66	66	template <int m_N, int _storage_N>
67		ATTR_HOT nl_double netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve()
	67	ATTR_HOT double netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve()
68	68	{
69	69	/*
70	70	* enable linear prediction on first newton pass
r242982	r242983
86	86
87	87	if (USE_LINEAR_PREDICTION)
88	88	{
89		nl_double sq = 0;
90		nl_double sqo = 0;
91		const nl_double rez_cts = 1.0 / this->current_timestep();
	89	double sq = 0;
	90	double sqo = 0;
	91	const double rez_cts = 1.0 / this->current_timestep();
92	92	for (int k = 0; k < this->N(); k++)
93	93	{
94	94	const netlist_analog_net_t *n = this->m_nets[k];
95		const nl_double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
	95	const double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
96	96	sq += nv * nv;
97	97	sqo += this->m_Vdelta[k] * this->m_Vdelta[k];
98	98	this->m_Vdelta[k] = nv;
r242982	r242983
116	116	*/
117	117
118	118	#if 0 || USE_MATRIX_GS
119		static nl_double ws = 1.0;
120		ATTR_ALIGN nl_double new_v[_storage_N] = { 0.0 };
	119	static double ws = 1.0;
	120	ATTR_ALIGN double new_v[_storage_N] = { 0.0 };
121	121	const int iN = this->N();
122	122
123	123	bool resched = false;
r242982	r242983
127	127	this->build_LE();
128	128
129	129	{
130		nl_double frob;
	130	double frob;
131	131	frob = 0;
132		nl_double rmin = 1e99, rmax = -1e99;
	132	double rmin = 1e99, rmax = -1e99;
133	133	for (int k = 0; k < iN; k++)
134	134	{
135	135	new_v[k] = this->m_nets[k]->m_cur_Analog;
136		nl_double s=0.0;
	136	double s=0.0;
137	137	for (int i = 0; i < iN; i++)
138	138	{
139	139	frob += this->m_A[k][i] * this->m_A[k][i];
r242982	r242983
146	146	rmax = s;
147	147	}
148	148	#if 0
149		nl_double frobA = sqrt(frob /(iN));
	149	double frobA = sqrt(frob /(iN));
150	150	if (1 &&frobA < 1.0)
151	151	//ws = 2.0 / (1.0 + sqrt(1.0-frobA));
152	152	ws = 2.0 / (2.0 - frobA);
r242982	r242983
161	161	// overhead is bigger than the gain. Consequently the fast GS below
162	162	// uses a fixed GS. One can however use this here to determine a
163	163	// suitable parameter.
164		nl_double rm = (rmax + rmin) * 0.5;
	164	double rm = (rmax + rmin) * 0.5;
165	165	if (rm < 1.0)
166	166	ws = 2.0 / (1.0 + sqrt(1.0-rm));
167	167	else
r242982	r242983
172	172	}
173	173
174	174	// Frobenius norm for (D-L)^(-1)U
175		//nl_double frobU;
176		//nl_double frobL;
177		//nl_double norm;
	175	//double frobU;
	176	//double frobL;
	177	//double norm;
178	178	do {
179	179	resched = false;
180		nl_double cerr = 0.0;
	180	double cerr = 0.0;
181	181	//frobU = 0;
182	182	//frobL = 0;
183	183	//norm = 0;
184	184
185	185	for (int k = 0; k < iN; k++)
186	186	{
187		nl_double Idrive = 0;
188		//nl_double norm_t = 0;
	187	double Idrive = 0;
	188	//double norm_t = 0;
189	189	// Reduction loops need -ffast-math
190	190	for (int i = 0; i < iN; i++)
191	191	Idrive += this->m_A[k][i] * new_v[i];
r242982	r242983
198	198	}
199	199
200	200	//if (norm_t > norm) norm = norm_t;
201		const nl_double new_val = (1.0-ws) * new_v[k] + ws * (this->m_RHS[k] - Idrive + this->m_A[k][k] * new_v[k]) / this->m_A[k][k];
	201	const double new_val = (1.0-ws) * new_v[k] + ws * (this->m_RHS[k] - Idrive + this->m_A[k][k] * new_v[k]) / this->m_A[k][k];
202	202
203		const nl_double e = fabs(new_val - new_v[k]);
	203	const double e = fabs(new_val - new_v[k]);
204	204	cerr = (e > cerr ? e : cerr);
205	205	new_v[k] = new_val;
206	206	}
r242982	r242983
210	210	resched = true;
211	211	}
212	212	resched_cnt++;
213		//ATTR_UNUSED nl_double frobUL = sqrt((frobU + frobL) / (double) (iN) / (double) (iN));
	213	//ATTR_UNUSED double frobUL = sqrt((frobU + frobL) / (double) (iN) / (double) (iN));
214	214	} while (resched && (resched_cnt < this->m_params.m_gs_loops));
215	215	//printf("Frobenius %f %f %f %f %f\n", sqrt(frobU), sqrt(frobL), frobUL, frobA, norm);
216	216	//printf("Omega Estimate1 %f %f\n", 2.0 / (1.0 + sqrt(1-frobUL)), 2.0 / (1.0 + sqrt(1-frobA)) ); //        printf("Frobenius %f\n", sqrt(frob / (double) (iN * iN) ));
r242982	r242983
247	247	* omega = 2.0 / (1.0 + sqrt(1-rho))
248	248	*/
249	249
250		const nl_double ws = this->m_params.m_sor; //1.045; //2.0 / (1.0 + /*sin*/(3.14159 * 5.5 / (double) (m_nets.count()+1)));
251		//const nl_double ws = 2.0 / (1.0 + sin(3.14159 * 4 / (double) (this->N())));
	250	const double ws = this->m_params.m_sor; //1.045; //2.0 / (1.0 + /*sin*/(3.14159 * 5.5 / (double) (m_nets.count()+1)));
	251	//const double ws = 2.0 / (1.0 + sin(3.14159 * 4 / (double) (this->N())));
252	252
253		ATTR_ALIGN nl_double w[_storage_N];
254		ATTR_ALIGN nl_double one_m_w[_storage_N];
255		ATTR_ALIGN nl_double RHS[_storage_N];
256		ATTR_ALIGN nl_double new_V[_storage_N];
	253	ATTR_ALIGN double w[_storage_N];
	254	ATTR_ALIGN double one_m_w[_storage_N];
	255	ATTR_ALIGN double RHS[_storage_N];
	256	ATTR_ALIGN double new_V[_storage_N];
257	257
258	258	for (int k = 0; k < iN; k++)
259	259	{
260		nl_double gtot_t = 0.0;
261		nl_double gabs_t = 0.0;
262		nl_double RHS_t = 0.0;
	260	double gtot_t = 0.0;
	261	double gabs_t = 0.0;
	262	double RHS_t = 0.0;
263	263
264	264	new_V[k] = this->m_nets[k]->m_cur_Analog;
265	265
266	266	{
267	267	const int term_count = this->m_terms[k]->count();
268		const nl_double * const RESTRICT gt = this->m_terms[k]->gt();
269		const nl_double * const RESTRICT go = this->m_terms[k]->go();
270		const nl_double * const RESTRICT Idr = this->m_terms[k]->Idr();
271		const nl_double * const *other_cur_analog = this->m_terms[k]->other_curanalog();
	268	const double * const RESTRICT gt = this->m_terms[k]->gt();
	269	const double * const RESTRICT go = this->m_terms[k]->go();
	270	const double * const RESTRICT Idr = this->m_terms[k]->Idr();
	271	const double * const *other_cur_analog = this->m_terms[k]->other_curanalog();
272	272	#if VECTALT
273	273	for (int i = 0; i < term_count; i++)
274	274	{
r242982	r242983
308	308
309	309	}
310	310
311		const nl_double accuracy = this->m_params.m_accuracy;
	311	const double accuracy = this->m_params.m_accuracy;
312	312
313	313	do {
314	314	resched = false;
r242982	r242983
317	317	{
318	318	const int * RESTRICT net_other = this->m_terms[k]->net_other();
319	319	const int railstart = this->m_terms[k]->m_railstart;
320		const nl_double * RESTRICT go = this->m_terms[k]->go();
	320	const double * RESTRICT go = this->m_terms[k]->go();
321	321
322		nl_double Idrive = 0.0;
	322	double Idrive = 0.0;
323	323	for (int i = 0; i < railstart; i++)
324	324	Idrive = Idrive + go[i] * new_V[net_other[i]];
325	325
326		//nl_double new_val = (net->m_cur_Analog * gabs[k] + iIdr) / (gtot[k]);
327		const nl_double new_val = new_V[k] * one_m_w[k] + (Idrive + RHS[k]) * w[k];
	326	//double new_val = (net->m_cur_Analog * gabs[k] + iIdr) / (gtot[k]);
	327	const double new_val = new_V[k] * one_m_w[k] + (Idrive + RHS[k]) * w[k];
328	328
329	329	resched = resched || (std::abs(new_val - new_V[k]) > accuracy);
330	330	new_V[k] = new_val;

trunk/src/emu/netlist/analog/nld_solver.c

r242982	r242983
233	233
234	234	ATTR_COLD void netlist_matrix_solver_t::update()
235	235	{
236		const nl_double new_timestep = solve();
	236	const double new_timestep = solve();
237	237
238	238	if (m_params.m_dynamic && is_timestep() && new_timestep > 0)
239	239	m_Q_sync.net().reschedule_in_queue(netlist_time::from_double(new_timestep));
r242982	r242983
241	241
242	242	ATTR_COLD void netlist_matrix_solver_t::update_forced()
243	243	{
244		ATTR_UNUSED const nl_double new_timestep = solve();
	244	ATTR_UNUSED const double new_timestep = solve();
245	245
246	246	if (m_params.m_dynamic && is_timestep())
247	247	m_Q_sync.net().reschedule_in_queue(netlist_time::from_double(m_params.m_min_timestep));
r242982	r242983
249	249
250	250	ATTR_HOT void netlist_matrix_solver_t::step(const netlist_time delta)
251	251	{
252		const nl_double dd = delta.as_double();
	252	const double dd = delta.as_double();
253	253	for (int k=0; k < m_step_devices.count(); k++)
254	254	m_step_devices[k]->step_time(dd);
255	255	}
r242982	r242983
284	284	}
285	285	}
286	286
287		ATTR_HOT nl_double netlist_matrix_solver_t::solve()
	287	ATTR_HOT double netlist_matrix_solver_t::solve()
288	288	{
289	289	netlist_time now = netlist().time();
290	290	netlist_time delta = now - m_last_step;
r242982	r242983
300	300
301	301	step(delta);
302	302
303		const nl_double next_time_step = vsolve();
	303	const double next_time_step = vsolve();
304	304
305	305	update_inputs();
306	306	return next_time_step;
r242982	r242983
348	348	register_param("GMIN", m_gmin, NETLIST_GMIN_DEFAULT);
349	349	register_param("DYNAMIC_TS", m_dynamic, 0);
350	350	register_param("LTE", m_lte, 5e-5);                     // diff/timestep
351		register_param("MIN_TIMESTEP", m_min_timestep, 1e-6);   // nl_double timestep resolution
	351	register_param("MIN_TIMESTEP", m_min_timestep, 1e-6);   // double timestep resolution
352	352
353	353	// internal staff
354	354
r242982	r242983
417	417	if (m_mat_solvers[i]->is_timestep())
418	418	{
419	419	// Ignore return value
420		ATTR_UNUSED const nl_double ts = m_mat_solvers[i]->solve();
	420	ATTR_UNUSED const double ts = m_mat_solvers[i]->solve();
421	421	}
422	422	}
423	423	#endif

trunk/src/emu/netlist/analog/nld_solver.h

r242982	r242983
37	37
38	38	struct netlist_solver_parameters_t
39	39	{
40		nl_double m_accuracy;
41		nl_double m_lte;
42		nl_double m_min_timestep;
43		nl_double m_max_timestep;
44		nl_double m_sor;
	40	double m_accuracy;
	41	double m_lte;
	42	double m_min_timestep;
	43	double m_max_timestep;
	44	double m_sor;
45	45	bool m_dynamic;
46	46	int m_gs_loops;
47	47	int m_nr_loops;
r242982	r242983
59	59
60	60	virtual ~vector_ops_t() {}
61	61
62		virtual const nl_double sum(const nl_double * v) = 0;
63		virtual void sum2(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, nl_double & RESTRICT  s1, nl_double & RESTRICT s2) = 0;
64		virtual void addmult(nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double &mult) = 0;
65		virtual void sum2a(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double * RESTRICT v3abs, nl_double & RESTRICT s1, nl_double & RESTRICT s2, nl_double & RESTRICT s3abs) = 0;
	62	virtual const double sum(const double * v) = 0;
	63	virtual void sum2(const double * RESTRICT v1, const double * RESTRICT v2, double & RESTRICT  s1, double & RESTRICT s2) = 0;
	64	virtual void addmult(double * RESTRICT v1, const double * RESTRICT v2, const double &mult) = 0;
	65	virtual void sum2a(const double * RESTRICT v1, const double * RESTRICT v2, const double * RESTRICT v3abs, double & RESTRICT s1, double & RESTRICT s2, double & RESTRICT s3abs) = 0;
66	66
67		virtual const nl_double sumabs(const nl_double * v) = 0;
	67	virtual const double sumabs(const double * v) = 0;
68	68
69	69	static vector_ops_t *create_ops(const int size);
70	70
r242982	r242983
95	95
96	96	ATTR_HOT inline const int N() const { if (m_N == 0) return m_dim; else return m_N; }
97	97
98		const nl_double sum(const nl_double * v)
	98	const double sum(const double * v)
99	99	{
100		const nl_double *  RESTRICT vl = v;
101		nl_double tmp = 0.0;
	100	const double *  RESTRICT vl = v;
	101	double tmp = 0.0;
102	102	for (int i=0; i < N(); i++)
103	103	tmp += vl[i];
104	104	return tmp;
105	105	}
106	106
107		void sum2(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, nl_double & RESTRICT s1, nl_double & RESTRICT s2)
	107	void sum2(const double * RESTRICT v1, const double * RESTRICT v2, double & RESTRICT s1, double & RESTRICT s2)
108	108	{
109		const nl_double * RESTRICT v1l = v1;
110		const nl_double * RESTRICT v2l = v2;
	109	const double * RESTRICT v1l = v1;
	110	const double * RESTRICT v2l = v2;
111	111	for (int i=0; i < N(); i++)
112	112	{
113	113	s1 += v1l[i];
r242982	r242983
115	115	}
116	116	}
117	117
118		void addmult(nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double &mult)
	118	void addmult(double * RESTRICT v1, const double * RESTRICT v2, const double &mult)
119	119	{
120		nl_double * RESTRICT v1l = v1;
121		const nl_double * RESTRICT v2l = v2;
	120	double * RESTRICT v1l = v1;
	121	const double * RESTRICT v2l = v2;
122	122	for (int i=0; i < N(); i++)
123	123	{
124	124	v1l[i] += v2l[i] * mult;
125	125	}
126	126	}
127	127
128		void sum2a(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double * RESTRICT v3abs, nl_double & RESTRICT s1, nl_double & RESTRICT s2, nl_double & RESTRICT s3abs)
	128	void sum2a(const double * RESTRICT v1, const double * RESTRICT v2, const double * RESTRICT v3abs, double & RESTRICT s1, double & RESTRICT s2, double & RESTRICT s3abs)
129	129	{
130		const nl_double * RESTRICT v1l = v1;
131		const nl_double * RESTRICT v2l = v2;
132		const nl_double * RESTRICT v3l = v3abs;
	130	const double * RESTRICT v1l = v1;
	131	const double * RESTRICT v2l = v2;
	132	const double * RESTRICT v3l = v3abs;
133	133	for (int i=0; i < N(); i++)
134	134	{
135	135	s1 += v1l[i];
r242982	r242983
138	138	}
139	139	}
140	140
141		const nl_double sumabs(const nl_double * v)
	141	const double sumabs(const double * v)
142	142	{
143		const nl_double * RESTRICT vl = v;
144		nl_double tmp = 0.0;
	143	const double * RESTRICT vl = v;
	144	double tmp = 0.0;
145	145	for (int i=0; i < N(); i++)
146	146	tmp += fabs(vl[i]);
147	147	return tmp;
r242982	r242983
171	171
172	172	ATTR_HOT inline netlist_terminal_t **terms() { return m_term; }
173	173	ATTR_HOT inline int *net_other() { return m_net_other; }
174		ATTR_HOT inline nl_double *gt() { return m_gt; }
175		ATTR_HOT inline nl_double *go() { return m_go; }
176		ATTR_HOT inline nl_double *Idr() { return m_Idr; }
177		ATTR_HOT inline nl_double **other_curanalog() { return m_other_curanalog; }
	174	ATTR_HOT inline double *gt() { return m_gt; }
	175	ATTR_HOT inline double *go() { return m_go; }
	176	ATTR_HOT inline double *Idr() { return m_Idr; }
	177	ATTR_HOT inline double **other_curanalog() { return m_other_curanalog; }
178	178
179	179	ATTR_COLD void set_pointers();
180	180
r242982	r242983
183	183	private:
184	184	plinearlist_t<netlist_terminal_t *> m_term;
185	185	plinearlist_t<int> m_net_other;
186		plinearlist_t<nl_double> m_go;
187		plinearlist_t<nl_double> m_gt;
188		plinearlist_t<nl_double> m_Idr;
189		plinearlist_t<nl_double *> m_other_curanalog;
	186	plinearlist_t<double> m_go;
	187	plinearlist_t<double> m_gt;
	188	plinearlist_t<double> m_Idr;
	189	plinearlist_t<double *> m_other_curanalog;
190	190	};
191	191
192	192	class netlist_matrix_solver_t : public netlist_device_t
r242982	r242983
209	209	template<class C>
210	210	void solve_base(C *p);
211	211
212		ATTR_HOT nl_double solve();
	212	ATTR_HOT double solve();
213	213
214	214	ATTR_HOT inline bool is_dynamic() { return m_dynamic_devices.count() > 0; }
215	215	ATTR_HOT inline bool is_timestep() { return m_step_devices.count() > 0; }
r242982	r242983
236	236	ATTR_HOT void update_dynamic();
237	237
238	238	// should return next time step
239		ATTR_HOT virtual nl_double vsolve() = 0;
	239	ATTR_HOT virtual double vsolve() = 0;
240	240
241	241	ATTR_COLD virtual void  add_term(int net_idx, netlist_terminal_t *term) = 0;
242	242
r242982	r242983
249	249
250	250	const netlist_solver_parameters_t &m_params;
251	251
252		ATTR_HOT inline const nl_double current_timestep() { return m_cur_ts; }
	252	ATTR_HOT inline const double current_timestep() { return m_cur_ts; }
253	253	private:
254	254
255	255	netlist_time m_last_step;
256		nl_double m_cur_ts;
	256	double m_cur_ts;
257	257	dev_list_t m_step_devices;
258	258	dev_list_t m_dynamic_devices;
259	259
r242982	r242983
279	279
280	280	ATTR_COLD void post_start();
281	281
282		ATTR_HOT inline nl_double gmin() { return m_gmin.Value(); }
	282	ATTR_HOT inline double gmin() { return m_gmin.Value(); }
283	283
284	284	protected:
285	285	ATTR_HOT void update();

trunk/src/emu/netlist/analog/nld_twoterm.c

r242982	r242983
16	16	set_param(1e-15, 1, 1e-15);
17	17	}
18	18
19		ATTR_COLD void netlist_generic_diode::set_param(const nl_double Is, const nl_double n, nl_double gmin)
	19	ATTR_COLD void netlist_generic_diode::set_param(const double Is, const double n, double gmin)
20	20	{
21	21	m_Is = Is;
22	22	m_n = n;
r242982	r242983
157	157
158	158	NETLIB_UPDATE_PARAM(POT)
159	159	{
160		nl_double v = m_Dial.Value();
	160	double v = m_Dial.Value();
161	161	if (m_DialIsLog.Value())
162	162	v = (exp(v) - 1.0) / (exp(1.0) - 1.0);
163	163
r242982	r242983
221	221
222	222	NETLIB_UPDATE_PARAM(D)
223	223	{
224		nl_double Is = m_model.model_value("Is", 1e-15);
225		nl_double n = m_model.model_value("N", 1);
	224	double Is = m_model.model_value("Is", 1e-15);
	225	double n = m_model.model_value("N", 1);
226	226
227	227	m_D.set_param(Is, n, netlist().gmin());
228	228	}

trunk/src/emu/netlist/analog/nld_twoterm.h

r242982	r242983
97	97	{
98	98	}
99	99
100		ATTR_HOT inline void set(const nl_double G, const nl_double V, const nl_double I)
	100	ATTR_HOT inline void set(const double G, const double V, const double I)
101	101	{
102	102	/*      GO, GT, I                */
103	103	m_P.set( G,  G, (  V) * G - I);
104	104	m_N.set( G,  G, ( -V) * G + I);
105	105	}
106	106
107		ATTR_HOT inline nl_double deltaV() const
	107	ATTR_HOT inline double deltaV() const
108	108	{
109	109	return m_P.net().as_analog().Q_Analog() - m_N.net().as_analog().Q_Analog();
110	110	}
111	111
112		ATTR_HOT void set_mat(nl_double a11, nl_double a12, nl_double a21, nl_double a22, nl_double r1, nl_double r2)
	112	ATTR_HOT void set_mat(double a11, double a12, double a21, double a22, double r1, double r2)
113	113	{
114	114	/*      GO, GT, I                */
115	115	m_P.set(-a12, a11, -r1);
r242982	r242983
133	133	public:
134	134	ATTR_COLD NETLIB_NAME(R_base)() : NETLIB_NAME(twoterm)(RESISTOR) { }
135	135
136		inline void set_R(const nl_double R)
	136	inline void set_R(const double R)
137	137	{
138	138	set(1.0 / R, 0.0, 0.0);
139	139	}
r242982	r242983
171	171	public:
172	172	ATTR_COLD NETLIB_NAME(C)() : NETLIB_NAME(twoterm)(CAPACITOR) { }
173	173
174		ATTR_HOT void step_time(const nl_double st)
	174	ATTR_HOT void step_time(const double st)
175	175	{
176		const nl_double G = m_C.Value() / st;
177		const nl_double I = -G * deltaV();
	176	const double G = m_C.Value() / st;
	177	const double I = -G * deltaV();
178	178	set(G, 0.0, I);
179	179	}
180	180
r242982	r242983
198	198	public:
199	199	ATTR_COLD netlist_generic_diode();
200	200
201		ATTR_HOT inline void update_diode(const nl_double nVd)
	201	ATTR_HOT inline void update_diode(const double nVd)
202	202	{
203	203	//FIXME: Optimize cutoff case
204	204
r242982	r242983
212	212	{
213	213	m_Vd = nVd;
214	214
215		const nl_double eVDVt = exp(m_Vd * m_VtInv);
	215	const double eVDVt = exp(m_Vd * m_VtInv);
216	216	m_Id = m_Is * (eVDVt - 1.0);
217	217	m_G = m_Is * m_VtInv * eVDVt + m_gmin;
218	218	}
r242982	r242983
221	221	#if defined(_MSC_VER) && _MSC_VER < 1800
222	222	m_Vd = m_Vd + log((nVd - m_Vd) * m_VtInv + 1.0) * m_Vt;
223	223	#else
224		nl_double a = (nVd - m_Vd) * m_VtInv;
	224	double a = (nVd - m_Vd) * m_VtInv;
225	225	if (a<1e-12 - 1.0) a = 1e-12 - 1.0;
226	226	m_Vd = m_Vd + log1p(a) * m_Vt;
227	227	#endif
228		const nl_double eVDVt = exp(m_Vd * m_VtInv);
	228	const double eVDVt = exp(m_Vd * m_VtInv);
229	229	m_Id = m_Is * (eVDVt - 1.0);
230	230
231	231	m_G = m_Is * m_VtInv * eVDVt + m_gmin;
r242982	r242983
234	234	//printf("nVd %f m_Vd %f Vcrit %f\n", nVd, m_Vd, m_Vcrit);
235	235	}
236	236
237		ATTR_COLD void set_param(const nl_double Is, const nl_double n, nl_double gmin);
	237	ATTR_COLD void set_param(const double Is, const double n, double gmin);
238	238
239		ATTR_HOT inline nl_double I() const { return m_Id; }
240		ATTR_HOT inline nl_double G() const { return m_G; }
241		ATTR_HOT inline nl_double Ieq() const { return (m_Id - m_Vd * m_G); }
242		ATTR_HOT inline nl_double Vd() const { return m_Vd; }
	239	ATTR_HOT inline double I() const { return m_Id; }
	240	ATTR_HOT inline double G() const { return m_G; }
	241	ATTR_HOT inline double Ieq() const { return (m_Id - m_Vd * m_G); }
	242	ATTR_HOT inline double Vd() const { return m_Vd; }
243	243
244	244	/* owning object must save those ... */
245	245
246	246	ATTR_COLD void save(pstring name, netlist_object_t &parent);
247	247
248	248	private:
249		nl_double m_Vd;
250		nl_double m_Id;
251		nl_double m_G;
	249	double m_Vd;
	250	double m_Id;
	251	double m_G;
252	252
253		nl_double m_Vt;
254		nl_double m_Is;
255		nl_double m_n;
256		nl_double m_gmin;
	253	double m_Vt;
	254	double m_Is;
	255	double m_n;
	256	double m_gmin;
257	257
258		nl_double m_VtInv;
259		nl_double m_Vcrit;
	258	double m_VtInv;
	259	double m_Vcrit;
260	260	};
261	261
262	262	// ----------------------------------------------------------------------------------------
r242982	r242983
268	268	// add c3 and it'll be better than 1%
269	269
270	270	#if 0
271		inline nl_double fastexp_h(const nl_double x)
	271	inline double fastexp_h(const double x)
272	272	{
273		static const nl_double ln2r = 1.442695040888963387;
274		static const nl_double ln2  = 0.693147180559945286;
275		//static const nl_double c3   = 0.166666666666666667;
	273	static const double ln2r = 1.442695040888963387;
	274	static const double ln2  = 0.693147180559945286;
	275	//static const double c3   = 0.166666666666666667;
276	276
277		const nl_double y = x * ln2r;
	277	const double y = x * ln2r;
278	278	const unsigned int t = y;
279		const nl_double z = (x - ln2 * (double) t);
280		const nl_double zz = z * z;
281		//const nl_double zzz = zz * z;
	279	const double z = (x - ln2 * (double) t);
	280	const double zz = z * z;
	281	//const double zzz = zz * z;
282	282
283	283	return (double)(1 << t)*(1.0 + z + 0.5 * zz); // + c3*zzz;
284	284	}
285	285
286		inline nl_double fastexp(const nl_double x)
	286	inline double fastexp(const double x)
287	287	{
288	288	if (x<0)
289	289	return 1.0 / fastexp_h(-x);

trunk/src/emu/netlist/devices/nld_4020.c

r242982	r242983
125	125	register_subalias("7", sub.m_Q[3]);
126	126	register_subalias("8", m_supply.m_vss);
127	127
128		register_subalias("9", sub.m_Q[0]);
	128	register_subalias("9", sub.m_Q[1]);
129	129	register_subalias("10", sub.m_IP);
130	130	register_subalias("11", m_RESET);
131	131	register_subalias("12", sub.m_Q[8]);

trunk/src/emu/netlist/devices/nld_4066.c

r242982	r242983
19	19
20	20	NETLIB_UPDATE(4066)
21	21	{
22		nl_double sup = (m_supply.get()->vdd() - m_supply.get()->vss());
23		nl_double low = 0.45 * sup;
24		nl_double high = 0.55 * sup;
25		nl_double in = INPANALOG(m_control) - m_supply.get()->vss();
26		nl_double rON = 270.0 * 5.0 / sup;
	22	double sup = (m_supply.get()->vdd() - m_supply.get()->vss());
	23	double low = 0.45 * sup;
	24	double high = 0.55 * sup;
	25	double in = INPANALOG(m_control) - m_supply.get()->vss();
	26	double rON = 270.0 * 5.0 / sup;
27	27
28	28	if (in < low)
29	29	{
r242982	r242983
53	53	register_subalias("4", m_B.m_R.m_N);
54	54	register_subalias("5", m_B.m_control);
55	55	register_subalias("6", m_C.m_control);
56		register_subalias("7", m_supply.m_vss);
	56	register_input("7", m_supply.m_vss);
57	57
58	58	register_subalias("8", m_C.m_R.m_P);
59	59	register_subalias("9", m_C.m_R.m_N);
r242982	r242983
61	61	register_subalias("11", m_D.m_R.m_N);
62	62	register_subalias("12", m_D.m_control);
63	63	register_subalias("13", m_A.m_control);
64		register_subalias("14", m_supply.m_vdd);
	64	register_input("14", m_supply.m_vdd);
65	65
66	66	}
67	67

trunk/src/emu/netlist/devices/nld_74123.c

r242982	r242983
69	69
70	70	if (m_state == 1)
71	71	{
72		const nl_double vLow = m_KP * TERMANALOG(m_RP.m_P);
	72	const double vLow = m_KP * TERMANALOG(m_RP.m_P);
73	73	if (INPANALOG(m_CV) < vLow)
74	74	{
75	75	m_RN.set_R(R_OFF);
r242982	r242983
78	78	}
79	79	else if (m_state == 2)
80	80	{
81		const nl_double vHigh = TERMANALOG(m_RP.m_P) * (1.0 - m_KP);
	81	const double vHigh = TERMANALOG(m_RP.m_P) * (1.0 - m_KP);
82	82	if (INPANALOG(m_CV) > vHigh)
83	83	{
84	84	m_RP.set_R(R_OFF);

trunk/src/emu/netlist/devices/nld_74ls629.c

r242982	r242983
104	104	{
105	105	{
106	106	// recompute
107		nl_double  freq;
108		nl_double  v_freq_2, v_freq_3, v_freq_4;
109		nl_double  v_freq = INPANALOG(m_FC);
110		nl_double  v_rng = INPANALOG(m_RNG);
	107	double  freq;
	108	double  v_freq_2, v_freq_3, v_freq_4;
	109	double  v_freq = INPANALOG(m_FC);
	110	double  v_rng = INPANALOG(m_RNG);
111	111
112	112	/* coefficients */
113		const nl_double k1 = 1.9904769024796283E+03;
114		const nl_double k2 = 1.2070059213983407E+03;
115		const nl_double k3 = 1.3266985579561108E+03;
116		const nl_double k4 = -1.5500979825922698E+02;
117		const nl_double k5 = 2.8184536266938172E+00;
118		const nl_double k6 = -2.3503421582744556E+02;
119		const nl_double k7 = -3.3836786704527788E+02;
120		const nl_double k8 = -1.3569136703258670E+02;
121		const nl_double k9 = 2.9914575453819188E+00;
122		const nl_double k10 = 1.6855569086173170E+00;
	113	const double k1 = 1.9904769024796283E+03;
	114	const double k2 = 1.2070059213983407E+03;
	115	const double k3 = 1.3266985579561108E+03;
	116	const double k4 = -1.5500979825922698E+02;
	117	const double k5 = 2.8184536266938172E+00;
	118	const double k6 = -2.3503421582744556E+02;
	119	const double k7 = -3.3836786704527788E+02;
	120	const double k8 = -1.3569136703258670E+02;
	121	const double k9 = 2.9914575453819188E+00;
	122	const double k10 = 1.6855569086173170E+00;
123	123
124	124	/* scale due to input resistance */
125	125

trunk/src/emu/netlist/devices/nld_cmos.h

r242982	r242983
29	29	ATTR_HOT void reset()  {};
30	30
31	31	public:
32		ATTR_HOT inline nl_double vdd() { return INPANALOG(m_vdd); }
33		ATTR_HOT inline nl_double vss() { return INPANALOG(m_vss); }
	32	ATTR_HOT inline double vdd() { return INPANALOG(m_vdd); }
	33	ATTR_HOT inline double vss() { return INPANALOG(m_vss); }
34	34	};
35	35
36	36	#endif /* NLD_CMOS_H_ */

trunk/src/emu/netlist/devices/nld_ne555.c

r242982	r242983
10	10	#define R_OFF (1E20)
11	11	#define R_ON (25)   // Datasheet states a maximum discharge of 200mA, R = 5V / 0.2
12	12
13		inline nl_double NETLIB_NAME(NE555)::clamp(const nl_double v, const nl_double a, const nl_double b)
	13	inline double NETLIB_NAME(NE555)::clamp(const double v, const double a, const double b)
14	14	{
15		nl_double ret = v;
16		nl_double vcc = TERMANALOG(m_R1.m_P);
	15	double ret = v;
	16	double vcc = TERMANALOG(m_R1.m_P);
17	17
18	18	if (ret >  vcc - a)
19	19	ret = vcc - a;
r242982	r242983
64	64	{
65	65	// FIXME: assumes GND is connected to 0V.
66	66
67		nl_double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
	67	double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
68	68	bool bthresh = (INPANALOG(m_THRES) > vt);
69	69	bool btrig = (INPANALOG(m_TRIG) > clamp(TERMANALOG(m_R2.m_N), 0.7, 1.4));
70	70	bool out = m_last_out;

trunk/src/emu/netlist/devices/nld_ne555.h

r242982	r242983
39	39
40	40	netlist_state_t<bool> m_last_out;
41	41
42		inline nl_double clamp(const nl_double v, const nl_double a, const nl_double b);
	42	inline double clamp(const double v, const double a, const double b);
43	43
44	44	);
45	45

trunk/src/emu/netlist/devices/nld_r2r_dac.c

r242982	r242983
32	32
33	33	update_dev();
34	34
35		nl_double V = m_VIN.Value() / (double) (1 << m_num.Value()) * (double) m_val.Value();
	35	double V = m_VIN.Value() / (double) (1 << m_num.Value()) * (double) m_val.Value();
36	36
37	37	this->set(1.0 / m_R.Value(), V, 0.0);
38	38	}

trunk/src/emu/netlist/devices/nld_system.c

r242982	r242983
118	118	if (state != m_last_state)
119	119	{
120	120	m_last_state = state;
121		const nl_double R = state ? m_logic_family->m_R_high : m_logic_family->m_R_low;
122		const nl_double V = state ? m_logic_family->m_high_V : m_logic_family->m_low_V;
	121	const double R = state ? m_logic_family->m_R_high : m_logic_family->m_R_low;
	122	const double V = state ? m_logic_family->m_high_V : m_logic_family->m_low_V;
123	123
124	124	// We only need to update the net first if this is a time stepping net
125	125	if (m_RV.m_P.net().as_analog().solver()->is_timestep())

trunk/src/emu/netlist/nl_base.c

r242982	r242983
170	170	netlist_object_t::save_register();
171	171	}
172	172
173		ATTR_HOT const nl_double netlist_base_t::gmin() const
	173	ATTR_HOT const double netlist_base_t::gmin() const
174	174	{
175	175	return solver()->gmin();
176	176	}
r242982	r242983
452	452	}
453	453
454	454	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const double initialVal);
455		template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const float initialVal);
456	455	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_int_t &param, const int initialVal);
457	456	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_logic_t &param, const int initialVal);
458	457	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_str_t &param, const char * const initialVal);
r242982	r242983
875	874	net().as_analog().m_cur_Analog = 0.98;
876	875	}
877	876
878		ATTR_COLD void netlist_analog_output_t::initial(const nl_double val)
	877	ATTR_COLD void netlist_analog_output_t::initial(const double val)
879	878	{
880	879	net().as_analog().m_cur_Analog = val * 0.99;
881	880	}
r242982	r242983
932	931	}
933	932
934	933
935		ATTR_COLD nl_double netlist_param_model_t::model_value(const pstring &entity, const nl_double defval) const
	934	ATTR_COLD double netlist_param_model_t::model_value(const pstring &entity, const double defval) const
936	935	{
937	936	pstring tmp = this->Value();
938	937	// .model 1N914 D(Is=2.52n Rs=.568 N=1.752 Cjo=4p M=.4 tt=20n Iave=200m Vpk=75 mfg=OnSemi type=silicon)
r242982	r242983
946	945	if (pequal < 0)
947	946	netlist().error("parameter %s misformat in model %s temp %s\n", entity.cstr(), Value().cstr(), tmp.cstr());
948	947	tmp = tmp.substr(pequal+1);
949		nl_double factor = 1.0;
	948	double factor = 1.0;
950	949	switch (*(tmp.right(1).cstr()))
951	950	{
952	951	case 'm': factor = 1e-3; break;
r242982	r242983
1002	1001	net.set_time(netlist().time() + m_inc);
1003	1002	}
1004	1003
	1004	// ----------------------------------------------------------------------------------------
	1005	// net_device_t_base_factory
	1006	// ----------------------------------------------------------------------------------------
	1007
	1008	ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::term_param_list()
	1009	{
	1010	if (m_def_param.startsWith("+"))
	1011	return nl_util::split(m_def_param.substr(1), ",");
	1012	else
	1013	return nl_util::pstring_list();
	1014	}
	1015
	1016	ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::def_params()
	1017	{
	1018	if (m_def_param.startsWith("+") || m_def_param.equals("-"))
	1019	return nl_util::pstring_list();
	1020	else
	1021	return nl_util::split(m_def_param, ",");
	1022	}

trunk/src/emu/netlist/nl_base.h

r242982	r242983
272	272
273	273	struct netlist_logic_family_desc_t
274	274	{
275		nl_double m_low_thresh_V;
276		nl_double m_high_thresh_V;
277		nl_double m_low_V;
278		nl_double m_high_V;
279		nl_double m_R_low;
280		nl_double m_R_high;
	275	double m_low_thresh_V;
	276	double m_high_thresh_V;
	277	double m_low_V;
	278	double m_high_V;
	279	double m_R_low;
	280	double m_R_high;
281	281	};
282	282
283	283	/* Terminals inherit the family description from the netlist_device
r242982	r242983
474	474
475	475	ATTR_COLD netlist_terminal_t();
476	476
477		nl_double *m_Idr1; // drive current
478		nl_double *m_go1;  // conductance for Voltage from other term
479		nl_double *m_gt1;  // conductance for total conductance
	477	double *m_Idr1; // drive current
	478	double *m_go1;  // conductance for Voltage from other term
	479	double *m_gt1;  // conductance for total conductance
480	480
481		ATTR_HOT inline void set(const nl_double G)
	481	ATTR_HOT inline void set(const double G)
482	482	{
483	483	set_ptr(m_Idr1, 0);
484	484	set_ptr(m_go1, G);
485	485	set_ptr(m_gt1, G);
486	486	}
487	487
488		ATTR_HOT inline void set(const nl_double GO, const nl_double GT)
	488	ATTR_HOT inline void set(const double GO, const double GT)
489	489	{
490	490	set_ptr(m_Idr1, 0);
491	491	set_ptr(m_go1, GO);
492	492	set_ptr(m_gt1, GT);
493	493	}
494	494
495		ATTR_HOT inline void set(const nl_double GO, const nl_double GT, const nl_double I)
	495	ATTR_HOT inline void set(const double GO, const double GT, const double I)
496	496	{
497	497	set_ptr(m_Idr1, I);
498	498	set_ptr(m_go1, GO);
r242982	r242983
509	509
510	510	ATTR_COLD virtual void reset();
511	511	private:
512		inline void set_ptr(nl_double *ptr, const nl_double val)
	512	inline void set_ptr(double *ptr, const double val)
513	513	{
514	514	if (ptr != NULL)
515	515	*ptr = val;
r242982	r242983
586	586	ATTR_COLD netlist_analog_input_t()
587	587	: netlist_input_t(INPUT, ANALOG) { }
588	588
589		ATTR_HOT inline const nl_double Q_Analog() const;
	589	ATTR_HOT inline const double Q_Analog() const;
590	590	};
591	591
592	592	//#define INPVAL(_x) (_x).Q()
r242982	r242983
661	661	// We have to have those on one object. Dividing those does lead
662	662	// to a significant performance hit
663	663	// FIXME: Have to fix the public at some time
664		nl_double m_cur_Analog;
	664	double m_cur_Analog;
665	665
666	666	};
667	667
r242982	r242983
736	736	ATTR_COLD netlist_analog_net_t();
737	737	ATTR_COLD virtual ~netlist_analog_net_t() { };
738	738
739		ATTR_HOT inline const nl_double Q_Analog() const
	739	ATTR_HOT inline const double Q_Analog() const
740	740	{
741	741	//nl_assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
742	742	nl_assert(family() == ANALOG);
743	743	return m_cur_Analog;
744	744	}
745	745
746		ATTR_COLD inline nl_double &Q_Analog_state_ptr()
	746	ATTR_COLD inline double &Q_Analog_state_ptr()
747	747	{
748	748	//nl_assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
749	749	nl_assert(family() == ANALOG);
r242982	r242983
764	764	private:
765	765
766	766	public:
767		nl_double m_DD_n_m_1;
768		nl_double m_h_n_m_1;
	767	double m_DD_n_m_1;
	768	double m_h_n_m_1;
769	769
770	770	//FIXME: needed by current solver code
771	771	netlist_matrix_solver_t *m_solver;
r242982	r242983
831	831
832	832	ATTR_COLD netlist_analog_output_t();
833	833
834		ATTR_COLD void initial(const nl_double val);
	834	ATTR_COLD void initial(const double val);
835	835
836		ATTR_HOT inline void set_Q(const nl_double newQ);
	836	ATTR_HOT inline void set_Q(const double newQ);
837	837
838	838	netlist_analog_net_t *m_proxied_net; // only for proxy nets in analog input logic
839	839
r242982	r242983
876	876	public:
877	877	ATTR_COLD netlist_param_double_t();
878	878
879		ATTR_HOT inline void setTo(const nl_double param);
880		ATTR_COLD inline void initial(const nl_double val) { m_param = val; }
881		ATTR_HOT inline const nl_double Value() const        { return m_param;   }
	879	ATTR_HOT inline void setTo(const double param);
	880	ATTR_COLD inline void initial(const double val) { m_param = val; }
	881	ATTR_HOT inline const double Value() const        { return m_param;   }
882	882
883	883	protected:
884	884	ATTR_COLD virtual void save_register()
r242982	r242983
888	888	}
889	889
890	890	private:
891		nl_double m_param;
	891	double m_param;
892	892	};
893	893
894	894	class netlist_param_int_t : public netlist_param_t
r242982	r242983
946	946	ATTR_HOT inline const pstring &Value() const     { return m_param;     }
947	947
948	948	/* these should be cached! */
949		ATTR_COLD nl_double model_value(const pstring &entity, const nl_double defval = 0.0) const;
	949	ATTR_COLD double model_value(const pstring &entity, const double defval = 0.0) const;
950	950	ATTR_COLD const pstring model_type() const;
951	951
952	952	private:
r242982	r242983
997	997	out.set_Q(val, delay);
998	998	}
999	999
1000		ATTR_HOT inline const nl_double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
	1000	ATTR_HOT inline const double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
1001	1001
1002		ATTR_HOT inline const nl_double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
	1002	ATTR_HOT inline const double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
1003	1003
1004		ATTR_HOT inline void OUTANALOG(netlist_analog_output_t &out, const nl_double val)
	1004	ATTR_HOT inline void OUTANALOG(netlist_analog_output_t &out, const double val)
1005	1005	{
1006	1006	out.set_Q(val);
1007	1007	}
r242982	r242983
1010	1010
1011	1011	ATTR_HOT virtual void dec_active() {  }
1012	1012
1013		ATTR_HOT virtual void step_time(const nl_double st) { }
	1013	ATTR_HOT virtual void step_time(const double st) { }
1014	1014	ATTR_HOT virtual void update_terminals() { }
1015	1015
1016	1016
r242982	r242983
1120	1120	ATTR_HOT inline const netlist_time time() const { return m_time; }
1121	1121	ATTR_HOT inline NETLIB_NAME(solver) *solver() const { return m_solver; }
1122	1122	ATTR_HOT inline NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
1123		ATTR_HOT const nl_double gmin() const;
	1123	ATTR_HOT const double gmin() const;
1124	1124
1125	1125	ATTR_HOT inline void push_to_queue(netlist_net_t *out, const netlist_time attime)
1126	1126	{
r242982	r242983
1251	1251	}
1252	1252	}
1253	1253
1254		ATTR_HOT inline void netlist_param_double_t::setTo(const nl_double param)
	1254	ATTR_HOT inline void netlist_param_double_t::setTo(const double param)
1255	1255	{
1256	1256	if (m_param != param)
1257	1257	{
r242982	r242983
1356	1356	return net().as_logic().Q();
1357	1357	}
1358	1358
1359		ATTR_HOT inline const nl_double netlist_analog_input_t::Q_Analog() const
	1359	ATTR_HOT inline const double netlist_analog_input_t::Q_Analog() const
1360	1360	{
1361	1361	return net().as_analog().Q_Analog();
1362	1362	}
1363	1363
1364		ATTR_HOT inline void netlist_analog_output_t::set_Q(const nl_double newQ)
	1364	ATTR_HOT inline void netlist_analog_output_t::set_Q(const double newQ)
1365	1365	{
1366	1366	if (newQ != net().as_analog().m_cur_Analog)
1367	1367	{

trunk/src/emu/netlist/nl_config.h

r242982	r242983
49	49
50	50	#define NETLIST_GMIN_DEFAULT    (1e-9)
51	51
52		//typedef double   nl_double;
53
54		#define nl_double double
55
56	52	//============================================================
57	53	//  DEBUGGING
58	54	//============================================================
r242982	r242983
159	155	#else
160	156	#define nl_assert(x)               do { } while (0)
161	157	//#define assert_always(x, msg)   do { if (!(x)) throw emu_fatalerror("Fatal error: %s (%s:%d)", msg, __FILE__, __LINE__); } while (0)
162		#define nl_assert_always(x, msg)    do { if (!(x)) throw nl_fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
	158	#define nl_assert_always(x, msg)   do { } while (0)
163	159	#endif
164	160
165	161	//============================================================

trunk/src/emu/netlist/nl_dice_compat.h

r242982	r242983
8	8	#ifndef NL_DICE_COMPAT_H_
9	9	#define NL_DICE_COMPAT_H_
10	10
11		#include "netlist/devices/net_lib.h"
12
13	11	/* --------------------------------------------------------------------
14	12	* Compatibility macros for DICE netlists ...
15	13	* -------------------------------------------------------------------- */
16	14
17		/*
18		* define NETLIST_DEVELOPMENT in IDEs before including this header file
19		* to get compile time errors on unknown devices. This should only be
20		* a temporary support and not be used in commits.
21		*/
22
23		#ifdef NETLIST_DEVELOPMENT
	15	//#define CHIP(_n, _t) netlist.register_dev(NET_NEW(_t ## _dip), _n);
24	16	#define CHIP(_n, _t) setup.register_dev( nl_alloc(nld_ ## _t ## _dip), _n);
25		#else
26		#define CHIP(_n, _t) setup.register_dev(NETLIB_NAME_STR(_t ## _dip), _n);
27		#endif
28	17
29	18	#define CONNECTION( ... ) CONNECTIONY( CONNECTIONX( __VA_ARGS__ ) )
30	19	#define CONNECTIONY(_a) _a
r242982	r242983
41	30	struct Mono555Desc
42	31	{
43	32	public:
44		nl_double r, c;
	33	double r, c;
45	34
46		Mono555Desc(nl_double res, nl_double cap) : r(res), c(cap) { }
	35	Mono555Desc(double res, double cap) : r(res), c(cap) { }
47	36	};
48	37
49	38	struct SeriesRCDesc
50	39	{
51	40	public:
52		nl_double r, c;
	41	double r, c;
53	42
54		SeriesRCDesc(nl_double res, nl_double cap) : r(res), c(cap) { }
	43	SeriesRCDesc(double res, double cap) : r(res), c(cap) { }
55	44	};
56	45
57	46	#define CHIP_555_Mono(_name,  _pdesc)   \

trunk/src/emu/netlist/nl_factory.c

r242982	r242983
50	50	#include "nl_factory.h"
51	51	#include "nl_setup.h"
52	52
53		// ----------------------------------------------------------------------------------------
54		// net_device_t_base_factory
55		// ----------------------------------------------------------------------------------------
56
57		ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::term_param_list()
58		{
59		if (m_def_param.startsWith("+"))
60		return nl_util::split(m_def_param.substr(1), ",");
61		else
62		return nl_util::pstring_list();
63		}
64
65		ATTR_COLD const nl_util::pstring_list net_device_t_base_factory::def_params()
66		{
67		if (m_def_param.startsWith("+") || m_def_param.equals("-"))
68		return nl_util::pstring_list();
69		else
70		return nl_util::split(m_def_param, ",");
71		}
72
73
74	53	netlist_factory_t::netlist_factory_t()
75	54	{
76	55	}
r242982	r242983
85	64	m_list.clear();
86	65	}
87	66
88		netlist_device_t *netlist_factory_t::new_device_by_classname(const pstring &classname) const
	67	netlist_device_t *netlist_factory_t::new_device_by_classname(const pstring &classname, netlist_setup_t &setup) const
89	68	{
90	69	for (net_device_t_base_factory * const *e = m_list.first(); e != NULL; e = m_list.next(e))
91	70	{
r242982	r242983
97	76	}
98	77	p++;
99	78	}
	79	setup.netlist().error("Class %s not found!\n", classname.cstr());
100	80	return NULL; // appease code analysis
101	81	}
102	82

trunk/src/emu/netlist/nl_factory.h

r242982	r242983
80	80	m_list.add(nl_alloc(net_device_t_factory< _C >, name, classname, def_param));
81	81	}
82	82
83		ATTR_COLD netlist_device_t *new_device_by_classname(const pstring &classname) const;
	83	ATTR_COLD netlist_device_t *new_device_by_classname(const pstring &classname, netlist_setup_t &setup) const;
84	84	ATTR_COLD netlist_device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const;
85	85	ATTR_COLD net_device_t_base_factory * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
86	86

trunk/src/emu/netlist/nl_parser.c

r242982	r242983
6	6	*/
7	7
8	8	#include "nl_parser.h"
9		#include "nl_factory.h"
10	9
11	10	//#undef NL_VERBOSE_OUT
12	11	//#define NL_VERBOSE_OUT(x) printf x
r242982	r242983
400	399	void netlist_parser::netdev_param()
401	400	{
402	401	pstring param;
403		nl_double val;
	402	double val;
404	403	param = get_identifier();
405	404	require_token(m_tok_comma);
406	405	val = eval_param(get_token());
r242982	r242983
440	439	}
441	440	else
442	441	{
443		nl_double val = eval_param(tok);
	442	double val = eval_param(tok);
444	443	m_setup.register_param(paramfq, val);
445	444	}
446	445	cnt++;
r242982	r242983
468	467	// ----------------------------------------------------------------------------------------
469	468
470	469
471		nl_double netlist_parser::eval_param(const token_t tok)
	470	double netlist_parser::eval_param(const token_t tok)
472	471	{
473	472	static const char *macs[6] = {"", "RES_K", "RES_M", "CAP_U", "CAP_N", "CAP_P"};
474		static nl_double facs[6] = {1, 1e3, 1e6, 1e-6, 1e-9, 1e-12};
	473	static double facs[6] = {1, 1e3, 1e6, 1e-6, 1e-9, 1e-12};
475	474	int i;
476	475	int f=0;
477	476	bool e;
478		nl_double ret;
	477	double ret;
479	478	pstring val;
480	479
481	480	//printf("param %s\n", tok.m_token.cstr());

trunk/src/emu/netlist/nl_parser.h

r242982	r242983
160	160	virtual void verror(pstring msg, int line_num, pstring line);
161	161	private:
162	162
163		nl_double eval_param(const token_t tok);
	163	double eval_param(const token_t tok);
164	164
165	165	token_id_t m_tok_param_left;
166	166	token_id_t m_tok_param_right;

trunk/src/emu/netlist/nl_setup.c

r242982	r242983
9	9	#include "nl_setup.h"
10	10	#include "nl_parser.h"
11	11	#include "nl_util.h"
12		#include "nl_factory.h"
13	12	#include "devices/net_lib.h"
14	13	#include "devices/nld_system.h"
15	14	#include "analog/nld_solver.h"
r242982	r242983
38	37	, m_proxy_cnt(0)
39	38	{
40	39	netlist.set_setup(this);
41		m_factory = nl_alloc(netlist_factory_t);
42	40	}
43	41
44	42	void netlist_setup_t::init()
r242982	r242983
57	55	m_params_temp.clear();
58	56
59	57	netlist().set_setup(NULL);
60		nl_free(m_factory);
61	58
62	59	pstring::resetmem();
63	60	}
r242982	r242983
95	92	return dev;
96	93	}
97	94
98		netlist_device_t *netlist_setup_t::register_dev(const pstring &classname, const pstring &name)
99		{
100		netlist_device_t *dev = factory().new_device_by_classname(classname);
101		if (dev == NULL)
102		netlist().error("Class %s not found!\n", classname.cstr());
103		return register_dev(dev, name);
104		}
105
106	95	template <class T>
107	96	static void remove_start_with(T &hm, pstring &sw)
108	97	{
r242982	r242983
706	695	{
707	696	NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
708	697	NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
709		netlist_device_t *nc = factory().new_device_by_classname("nld_log");
	698	netlist_device_t *nc = factory().new_device_by_classname("nld_log", *this);
710	699	pstring name = "log_" + ll[i];
711	700	register_dev(nc, name);
712	701	register_link(name + ".I", ll[i]);

trunk/src/emu/netlist/nl_setup.h

r242982	r242983
3	3	/*
4	4	* nlsetup.h
5	5	*
	6	*  Created on: 3 Nov 2013
	7	*      Author: andre
6	8	*/
7	9
8	10	#ifndef NLSETUP_H_
9	11	#define NLSETUP_H_
10	12
11	13	#include "nl_base.h"
12		//#include "nl_factory.h"
	14	#include "nl_factory.h"
13	15
14	16	//============================================================
15	17	//  MACROS / inline netlist definitions
r242982	r242983
23	25	#define ALIAS(_alias, _name)                                                        \
24	26	setup.register_alias(# _alias, # _name);
25	27
26		//#define NET_NEW(_type)  setup.factory().new_device_by_classname(NETLIB_NAME_STR(_type), setup)
	28	#define NET_NEW(_type)  setup.factory().new_device_by_classname(NETLIB_NAME_STR(_type), setup)
27	29
28	30	#define NET_REGISTER_DEV(_type, _name)                                              \
29		setup.register_dev(NETLIB_NAME_STR(_type), # _name);
	31	setup.register_dev(NET_NEW(_type), # _name);
30	32
31	33	#define NET_REMOVE_DEV(_name)                                                       \
32	34	setup.remove_dev(# _name);
r242982	r242983
65	67	setup.namespace_pop();
66	68
67	69	// ----------------------------------------------------------------------------------------
	70	// FIXME: Clean this up
	71	// ----------------------------------------------------------------------------------------
	72
	73	//class NETLIB_NAME(analog_callback);
	74
	75	// ----------------------------------------------------------------------------------------
68	76	// netlist_setup_t
69	77	// ----------------------------------------------------------------------------------------
70	78
71		// Forward definition so we keep nl_factory.h out of the public
72		class netlist_factory_t;
73
74	79	class netlist_setup_t
75	80	{
76	81	NETLIST_PREVENT_COPYING(netlist_setup_t)
r242982	r242983
113	118
114	119	netlist_base_t &netlist() { return m_netlist; }
115	120	const netlist_base_t &netlist() const { return m_netlist; }
	121	netlist_factory_t &factory() { return m_factory; }
	122	const netlist_factory_t &factory() const { return m_factory; }
116	123
117	124	pstring build_fqn(const pstring &obj_name) const;
118	125
119	126	netlist_device_t *register_dev(netlist_device_t *dev, const pstring &name);
120		netlist_device_t *register_dev(const pstring &classname, const pstring &name);
121	127	void remove_dev(const pstring &name);
122	128
123	129	void register_model(const pstring &model);
r242982	r242983
146	152	void namespace_push(const pstring &aname);
147	153	void namespace_pop();
148	154
149		netlist_factory_t &factory() { return *m_factory; }
150		const netlist_factory_t &factory() const { return *m_factory; }
	155	/* not ideal, but needed for save_state */
	156	tagmap_terminal_t  m_terminals;
151	157
152		/* not ideal, but needed for save_state */
153		tagmap_terminal_t  m_terminals;
	158	void print_stats() const;
154	159
155		void print_stats() const;
156
157	160	protected:
158	161
159	162	private:
r242982	r242983
165	168	tagmap_link_t   m_links;
166	169	tagmap_nstring_t m_params_temp;
167	170
168		netlist_factory_t *m_factory;
	171	netlist_factory_t m_factory;
169	172
170	173	plinearlist_t<pstring> m_models;
171	174

trunk/src/emu/netlist/pstate.c

r242982	r242983
23	23	"DT_INT16",
24	24	"DT_INT8",
25	25	"DT_INT",
26		"DT_BOOLEAN",
27		"DT_FLOAT"
	26	"DT_BOOLEAN"
28	27	};
29	28
30	29	NL_VERBOSE_OUT(("SAVE: <%s> %s(%d) %p\n", fullname.cstr(), ts[dt].cstr(), size, ptr));

trunk/src/emu/netlist/pstate.h

r242982	r242983
32	32	DT_INT16,
33	33	DT_INT8,
34	34	DT_INT,
35		DT_BOOLEAN,
36		DT_FLOAT
	35	DT_BOOLEAN
37	36	};
38	37
39	38	template<typename _ItemType> struct nl_datatype
r242982	r242983
56	55
57	56	NETLIST_SAVE_TYPE(char, DT_INT8);
58	57	NETLIST_SAVE_TYPE(double, DT_DOUBLE);
59		NETLIST_SAVE_TYPE(float, DT_FLOAT);
60	58	NETLIST_SAVE_TYPE(INT8, DT_INT8);
61	59	NETLIST_SAVE_TYPE(UINT8, DT_INT8);
62	60	NETLIST_SAVE_TYPE(INT64, DT_INT64);

trunk/src/emu/netlist/pstring.c

r242982	r242983
108	108	return 1;
109	109	}
110	110
111		nl_double pstring::as_double(bool *error) const
	111	double pstring::as_double(bool *error) const
112	112	{
113		nl_double ret;
	113	double ret;
114	114	char *e = NULL;
115	115
116	116	if (error != NULL)
r242982	r242983
124	124
125	125	long pstring::as_long(bool *error) const
126	126	{
127		nl_double ret;
	127	double ret;
128	128	char *e = NULL;
129	129
130	130	if (error != NULL)

trunk/src/emu/netlist/pstring.h

r242982	r242983
159	159
160	160	// conversions
161	161
162		nl_double as_double(bool *error = NULL) const;
	162	double as_double(bool *error = NULL) const;
163	163
164	164	long as_long(bool *error = NULL) const;
165	165

trunk/src/mame/drivers/nl_pongd.c

r242982	r242983
65	65	*
66	66	*/
67	67
68		// identify unknown devices in IDE
69	68
70		//#define NETLIST_DEVELOPMENT 1
71
72	69	#include "netlist/nl_dice_compat.h"
73	70	#include "netlist/devices/net_lib.h"
74	71	#include "netlist/analog/nld_twoterm.h"

trunk/src/tools/nltool.c

r242982	r242983
18	18	#include "netlist/nl_base.h"
19	19	#include "netlist/nl_setup.h"
20	20	#include "netlist/nl_parser.h"
21		#include "netlist/nl_factory.h"
22	21	#include "netlist/nl_util.h"
23		#include "netlist/devices/net_lib.h"
24	22	#include "options.h"
25	23
26	24	/***************************************************************************
27		* MAME COMPATIBILITY ...
28		*
29		* These are needed if we link without libutil
30		***************************************************************************/
	25	MAME COMPATIBILITY ...
	26	***************************************************************************/
31	27
32	28	#if 0
33	29	void ATTR_PRINTF(1,2) osd_printf_warning(const char *format, ...)
r242982	r242983
39	35	vprintf(format, argptr);
40	36	va_end(argptr);
41	37	}
	38	#endif
42	39
43	40	void *malloc_file_line(size_t size, const char *file, int line)
44	41	{
r242982	r242983
75	72	src_type.name(), dst_type.name());
76	73	throw;
77	74	}
78		#endif
79	75
80	76	struct options_entry oplist[] =
81	77	{
r242982	r242983
87	83	{ NULL }
88	84	};
89	85
90		NETLIST_START(dummy)
91		/* Standard stuff */
92
93		CLOCK(clk, 1000) // 1000 Hz
94		SOLVER(Solver, 48000)
95
96		NETLIST_END()
97
98	86	/***************************************************************************
99	87	CORE IMPLEMENTATION
100	88	***************************************************************************/
r242982	r242983
172	160	nl_util::pstring_list ll = nl_util::split(m_logs, ":");
173	161	for (int i=0; i < ll.count(); i++)
174	162	{
175		pstring name = "log_" + ll[i];
176		netlist_device_t *nc = m_setup->register_dev("nld_log", name);
	163	netlist_device_t *nc = m_setup->factory().new_device_by_classname("nld_log", *m_setup);
	164	pstring name = "log_" + ll[i];
	165	m_setup->register_dev(nc, name);
177	166	m_setup->register_link(name + ".I", ll[i]);
178	167	}
179	168	}
r242982	r242983
241	230	nt.init();
242	231	const netlist_factory_t::list_t &list = nt.setup().factory().list();
243	232
244		netlist_sources_t sources;
245
246		sources.add(netlist_source_t("dummy", &netlist_dummy));
247		sources.parse(nt.setup(),"dummy");
248
249	233	nt.setup().start_devices();
250	234	nt.setup().resolve_inputs();
251	235

https://github.com/mamedev/mame/commit/c95ed9c31da9d390ba4b8052f7e5a198cd572abc

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team