Previous

199869 Revisions

Next

r35320 Sunday 18th January, 2015 at 10:48:39 UTC by Couriersud
Introduced an nl_double type. This will be followed by an nl_float type for certain components (mostly matrix and vector). (nw)

[/branches/kale/src/emu/machine]	netlist.c
[/branches/kale/src/emu/netlist]	nl_base.c nl_base.h nl_config.h nl_dice_compat.h nl_parser.c nl_parser.h pstate.c pstate.h pstring.c pstring.h
[/branches/kale/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
[/branches/kale/src/emu/netlist/devices]	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
[/branches/kale/src/mame/includes]	mario.h

branches/kale/src/emu/machine/netlist.c

r243831	r243832
443	443	if (td != NULL) save_pointer(td, s->m_name, s->m_count);
444	444	}
445	445	break;
	446	case DT_FLOAT:
	447	{
	448	float *td = s->resolved<float>();
	449	if (td != NULL) save_pointer(td, s->m_name, s->m_count);
	450	}
	451	break;
446	452	case DT_INT64:
447	453	save_pointer((INT64 *) s->m_ptr, s->m_name, s->m_count);
448	454	break;

branches/kale/src/emu/netlist/analog/nld_bjt.c

r243831	r243832
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 double Is, const double n)
	14	diode(const nl_double Is, const nl_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 double Is, const double n)
	20	void set(const nl_double Is, const nl_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		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); }
	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); }
30	30
31	31	private:
32		double m_Is;
33		double m_VT;
34		double m_VT_inv;
	32	nl_double m_Is;
	33	nl_double m_VT;
	34	nl_double m_VT_inv;
35	35	};
36	36
37	37
r243831	r243832
85	85	m_state_on = 0;
86	86
87	87	{
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);
	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);
92	92
93	93	set_qtype((m_model.model_type() == "NPN") ? BJT_NPN : BJT_PNP);
94	94
95		double alpha = BF / (1.0 + BF);
	95	nl_double alpha = BF / (1.0 + BF);
96	96
97	97	diode d(IS, NF);
98	98
r243831	r243832
155	155	m_gD_BC.save("m_D_BC", *this);
156	156
157	157	{
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);
	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);
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());

branches/kale/src/emu/netlist/analog/nld_bjt.h

r243831	r243832
98	98
99	99	NETLIB_UPDATE_TERMINALS()
100	100	{
101		const double m = (is_qtype( BJT_NPN) ? 1 : -1);
	101	const nl_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		double gb = m_gB;
108		double gc = m_gC;
109		double v  = m_V * m;
	107	nl_double gb = m_gB;
	108	nl_double gc = m_gC;
	109	nl_double v  = m_V * m;
110	110	if (!new_state )
111	111	{
112	112	// not conducting
r243831	r243832
115	115	gc = netlist().gmin();
116	116	}
117	117	#else
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;
	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;
121	121	#endif
122	122	m_RB.set(gb, v,   0.0);
123	123	m_RC.set(gc, 0.0, 0.0);
r243831	r243832
142	142	ATTR_COLD virtual void start();
143	143	ATTR_HOT void update_param();
144	144
145		double m_gB; // base conductance / switch on
146		double m_gC; // collector conductance / switch on
147		double m_V; // internal voltage source
	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
148	148	UINT8 m_state_on;
149	149
150	150	private:
r243831	r243832
169	169
170	170	NETLIB_UPDATE_TERMINALS()
171	171	{
172		const double polarity = (qtype() == BJT_NPN ? 1.0 : -1.0);
	172	const nl_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 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;
	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;
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);
r243831	r243832
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		double m_alpha_f;
206		double m_alpha_r;
	205	nl_double m_alpha_f;
	206	nl_double m_alpha_r;
207	207
208	208	private:
209	209	};

branches/kale/src/emu/netlist/analog/nld_fourterm.c

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

branches/kale/src/emu/netlist/analog/nld_fourterm.h

r243831	r243832
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 double def_RI);
	62	ATTR_COLD void start_internal(const nl_double def_RI);
63	63
64	64	netlist_terminal_t m_OP;
65	65	netlist_terminal_t m_ON;
r243831	r243832
73	73	netlist_param_double_t m_G;
74	74	netlist_param_double_t m_RI;
75	75
76		double m_gfac;
	76	nl_double m_gfac;
77	77	};
78	78
79	79	// ----------------------------------------------------------------------------------------
r243831	r243832
115	115	ATTR_COLD virtual void update_param();
116	116	ATTR_HOT ATTR_ALIGN void update();
117	117
118		double m_gfac;
	118	nl_double m_gfac;
119	119	};
120	120
121	121

branches/kale/src/emu/netlist/analog/nld_ms_direct.h

r243831	r243832
28	28	protected:
29	29	ATTR_COLD virtual void add_term(int net_idx, netlist_terminal_t *term);
30	30
31		ATTR_HOT virtual double vsolve();
	31	ATTR_HOT virtual nl_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(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);
	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);
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 double compute_next_timestep();
	43	ATTR_HOT nl_double compute_next_timestep();
44	44
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];
	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];
50	50
51	51	terms_t **m_terms;
52	52	terms_t *m_rails_temp;
r243831	r243832
55	55	vector_ops_t *m_row_ops[_storage_N + 1];
56	56
57	57	int m_dim;
58		double m_lp_fact;
	58	nl_double m_lp_fact;
59	59	};
60	60
61	61	// ----------------------------------------------------------------------------------------
r243831	r243832
84	84	}
85	85
86	86	template <int m_N, int _storage_N>
87		ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
	87	ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
88	88	{
89		double new_solver_timestep = m_params.m_max_timestep;
	89	nl_double new_solver_timestep = m_params.m_max_timestep;
90	90
91	91	if (m_params.m_dynamic)
92	92	{
r243831	r243832
103	103	{
104	104	netlist_analog_net_t *n = m_nets[k];
105	105	#endif
106		const double DD_n = (n->m_cur_Analog - m_last_V[k]);
107		const double hn = current_timestep();
	106	const nl_double DD_n = (n->m_cur_Analog - m_last_V[k]);
	107	const nl_double hn = current_timestep();
108	108
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;
	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;
111	111
112	112	n->m_h_n_m_1 = hn;
113	113	n->m_DD_n_m_1 = DD_n;
r243831	r243832
236	236	for (int i=0; i < N(); i++)
237	237	m_A[k][i] = 0.0;
238	238
239		double rhsk = 0.0;
240		double akk  = 0.0;
	239	nl_double rhsk = 0.0;
	240	nl_double akk  = 0.0;
241	241	{
242	242	const int terms_count = m_terms[k]->count();
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();
	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();
246	246	#if VECTALT
247	247
248	248	for (int i = 0; i < terms_count; i++)
r243831	r243832
253	253	#else
254	254	m_terms[k]->ops()->sum2(Idr, gt, rhsk, akk);
255	255	#endif
256		double * const * RESTRICT other_cur_analog = m_terms[k]->other_curanalog();
	256	nl_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();
r243831	r243832
272	272	m_A[k][k] += 1.0;
273	273	{
274	274	const int *net_other = m_terms[k]->net_other();
275		const double *go = m_terms[k]->go();
	275	const nl_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++)
r243831	r243832
285	285	m_A[k][k] += akk;
286	286	{
287	287	const int * RESTRICT net_other = m_terms[k]->net_other();
288		const double * RESTRICT go = m_terms[k]->go();
	288	const nl_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++)
r243831	r243832
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		double (* RESTRICT x))
	302	nl_double (* RESTRICT x))
303	303	{
304	304	#if 0
305	305	for (int i = 0; i < N(); i++)
r243831	r243832
336	336	}
337	337
338	338	/* FIXME: Singular matrix? */
339		const double f = 1.0 / m_A[i][i];
	339	const nl_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 double f1 = - m_A[j][i] * f;
	345	const nl_double f1 = - m_A[j][i] * f;
346	346	if (f1 != 0.0)
347	347	{
348	348	#if 0 && VECTALT
r243831	r243832
359	359	/* back substitution */
360	360	for (int j = kN - 1; j >= 0; j--)
361	361	{
362		double tmp = 0;
	362	nl_double tmp = 0;
363	363
364	364	for (int k = j + 1; k < kN; k++)
365	365	tmp += m_A[j][k] * x[k];
r243831	r243832
380	380	}
381	381
382	382	template <int m_N, int _storage_N>
383		ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
384		const double (* RESTRICT V))
	383	ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
	384	const nl_double (* RESTRICT V))
385	385	{
386		double cerr = 0;
387		double cerr2 = 0;
	386	nl_double cerr = 0;
	387	nl_double cerr2 = 0;
388	388	for (int i = 0; i < this->N(); i++)
389	389	{
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]);
	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]);
392	392	cerr = (fabs(e) > cerr ? fabs(e) : cerr);
393	393	cerr2 = (fabs(e2) > cerr2 ? fabs(e2) : cerr2);
394	394	}
r243831	r243832
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 double (* RESTRICT V), const bool store_RHS)
	401	const nl_double (* RESTRICT V), const bool store_RHS)
402	402	{
403	403	for (int i = 0; i < this->N(); i++)
404	404	{
r243831	r243832
414	414	}
415	415
416	416	template <int m_N, int _storage_N>
417		ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::vsolve()
	417	ATTR_HOT nl_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();
r243831	r243832
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		double new_v[_storage_N] = { 0.0 };
	427	nl_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		double err = delta(new_v);
	433	nl_double err = delta(new_v);
434	434
435	435	store(new_v, true);
436	436

branches/kale/src/emu/netlist/analog/nld_ms_direct1.h

r243831	r243832
18	18	{}
19	19	ATTR_HOT inline int vsolve_non_dynamic();
20	20	protected:
21		ATTR_HOT virtual double vsolve();
	21	ATTR_HOT virtual nl_double vsolve();
22	22	private:
23	23	};
24	24
r243831	r243832
26	26	// netlist_matrix_solver - Direct1
27	27	// ----------------------------------------------------------------------------------------
28	28
29		ATTR_HOT double netlist_matrix_solver_direct1_t::vsolve()
	29	ATTR_HOT nl_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();
r243831	r243832
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		double new_val =  m_RHS[0] / m_A[0][0];
	41	nl_double new_val =  m_RHS[0] / m_A[0][0];
42	42
43		double e = (new_val - net->m_cur_Analog);
44		double cerr = fabs(e);
	43	nl_double e = (new_val - net->m_cur_Analog);
	44	nl_double cerr = fabs(e);
45	45
46	46	net->m_cur_Analog = new_val;
47	47

branches/kale/src/emu/netlist/analog/nld_ms_direct2.h

r243831	r243832
20	20	{}
21	21	ATTR_HOT inline int vsolve_non_dynamic();
22	22	protected:
23		ATTR_HOT virtual double vsolve();
	23	ATTR_HOT virtual nl_double vsolve();
24	24	private:
25	25	};
26	26
r243831	r243832
28	28	// netlist_matrix_solver - Direct2
29	29	// ----------------------------------------------------------------------------------------
30	30
31		ATTR_HOT double netlist_matrix_solver_direct2_t::vsolve()
	31	ATTR_HOT nl_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();
r243831	r243832
38	38	{
39	39	build_LE();
40	40
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];
	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];
45	45
46		double new_val[2];
	46	nl_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		double err = this->delta(new_val);
	52	nl_double err = this->delta(new_val);
53	53	store(new_val, true);
54	54	if (err > m_params.m_accuracy )
55	55	return 2;

branches/kale/src/emu/netlist/analog/nld_ms_gauss_seidel.h

r243831	r243832
29	29
30	30	ATTR_HOT inline int vsolve_non_dynamic();
31	31	protected:
32		ATTR_HOT virtual double vsolve();
	32	ATTR_HOT virtual nl_double vsolve();
33	33
34	34	private:
35		double m_lp_fact;
	35	nl_double m_lp_fact;
36	36	int m_gs_fail;
37	37	int m_gs_total;
38	38
r243831	r243832
64	64	}
65	65
66	66	template <int m_N, int _storage_N>
67		ATTR_HOT double netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve()
	67	ATTR_HOT nl_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
r243831	r243832
86	86
87	87	if (USE_LINEAR_PREDICTION)
88	88	{
89		double sq = 0;
90		double sqo = 0;
91		const double rez_cts = 1.0 / this->current_timestep();
	89	nl_double sq = 0;
	90	nl_double sqo = 0;
	91	const nl_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 double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
	95	const nl_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;
r243831	r243832
116	116	*/
117	117
118	118	#if 0 || USE_MATRIX_GS
119		static double ws = 1.0;
120		ATTR_ALIGN double new_v[_storage_N] = { 0.0 };
	119	static nl_double ws = 1.0;
	120	ATTR_ALIGN nl_double new_v[_storage_N] = { 0.0 };
121	121	const int iN = this->N();
122	122
123	123	bool resched = false;
r243831	r243832
127	127	this->build_LE();
128	128
129	129	{
130		double frob;
	130	nl_double frob;
131	131	frob = 0;
132		double rmin = 1e99, rmax = -1e99;
	132	nl_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		double s=0.0;
	136	nl_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];
r243831	r243832
146	146	rmax = s;
147	147	}
148	148	#if 0
149		double frobA = sqrt(frob /(iN));
	149	nl_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);
r243831	r243832
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		double rm = (rmax + rmin) * 0.5;
	164	nl_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
r243831	r243832
172	172	}
173	173
174	174	// Frobenius norm for (D-L)^(-1)U
175		//double frobU;
176		//double frobL;
177		//double norm;
	175	//nl_double frobU;
	176	//nl_double frobL;
	177	//nl_double norm;
178	178	do {
179	179	resched = false;
180		double cerr = 0.0;
	180	nl_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		double Idrive = 0;
188		//double norm_t = 0;
	187	nl_double Idrive = 0;
	188	//nl_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];
r243831	r243832
198	198	}
199	199
200	200	//if (norm_t > norm) norm = norm_t;
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];
	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];
202	202
203		const double e = fabs(new_val - new_v[k]);
	203	const nl_double e = fabs(new_val - new_v[k]);
204	204	cerr = (e > cerr ? e : cerr);
205	205	new_v[k] = new_val;
206	206	}
r243831	r243832
210	210	resched = true;
211	211	}
212	212	resched_cnt++;
213		//ATTR_UNUSED double frobUL = sqrt((frobU + frobL) / (double) (iN) / (double) (iN));
	213	//ATTR_UNUSED nl_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) ));
r243831	r243832
247	247	* omega = 2.0 / (1.0 + sqrt(1-rho))
248	248	*/
249	249
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())));
	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())));
252	252
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];
	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];
257	257
258	258	for (int k = 0; k < iN; k++)
259	259	{
260		double gtot_t = 0.0;
261		double gabs_t = 0.0;
262		double RHS_t = 0.0;
	260	nl_double gtot_t = 0.0;
	261	nl_double gabs_t = 0.0;
	262	nl_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 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();
	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();
272	272	#if VECTALT
273	273	for (int i = 0; i < term_count; i++)
274	274	{
r243831	r243832
308	308
309	309	}
310	310
311		const double accuracy = this->m_params.m_accuracy;
	311	const nl_double accuracy = this->m_params.m_accuracy;
312	312
313	313	do {
314	314	resched = false;
r243831	r243832
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 double * RESTRICT go = this->m_terms[k]->go();
	320	const nl_double * RESTRICT go = this->m_terms[k]->go();
321	321
322		double Idrive = 0.0;
	322	nl_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		//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];
	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];
328	328
329	329	resched = resched || (std::abs(new_val - new_V[k]) > accuracy);
330	330	new_V[k] = new_val;

branches/kale/src/emu/netlist/analog/nld_solver.c

r243831	r243832
233	233
234	234	ATTR_COLD void netlist_matrix_solver_t::update()
235	235	{
236		const double new_timestep = solve();
	236	const nl_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));
r243831	r243832
241	241
242	242	ATTR_COLD void netlist_matrix_solver_t::update_forced()
243	243	{
244		ATTR_UNUSED const double new_timestep = solve();
	244	ATTR_UNUSED const nl_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));
r243831	r243832
249	249
250	250	ATTR_HOT void netlist_matrix_solver_t::step(const netlist_time delta)
251	251	{
252		const double dd = delta.as_double();
	252	const nl_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	}
r243831	r243832
284	284	}
285	285	}
286	286
287		ATTR_HOT double netlist_matrix_solver_t::solve()
	287	ATTR_HOT nl_double netlist_matrix_solver_t::solve()
288	288	{
289	289	netlist_time now = netlist().time();
290	290	netlist_time delta = now - m_last_step;
r243831	r243832
300	300
301	301	step(delta);
302	302
303		const double next_time_step = vsolve();
	303	const nl_double next_time_step = vsolve();
304	304
305	305	update_inputs();
306	306	return next_time_step;
r243831	r243832
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);   // double timestep resolution
	351	register_param("MIN_TIMESTEP", m_min_timestep, 1e-6);   // nl_double timestep resolution
352	352
353	353	// internal staff
354	354
r243831	r243832
417	417	if (m_mat_solvers[i]->is_timestep())
418	418	{
419	419	// Ignore return value
420		ATTR_UNUSED const double ts = m_mat_solvers[i]->solve();
	420	ATTR_UNUSED const nl_double ts = m_mat_solvers[i]->solve();
421	421	}
422	422	}
423	423	#endif

branches/kale/src/emu/netlist/analog/nld_solver.h

r243831	r243832
37	37
38	38	struct netlist_solver_parameters_t
39	39	{
40		double m_accuracy;
41		double m_lte;
42		double m_min_timestep;
43		double m_max_timestep;
44		double m_sor;
	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;
45	45	bool m_dynamic;
46	46	int m_gs_loops;
47	47	int m_nr_loops;
r243831	r243832
59	59
60	60	virtual ~vector_ops_t() {}
61	61
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;
	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;
66	66
67		virtual const double sumabs(const double * v) = 0;
	67	virtual const nl_double sumabs(const nl_double * v) = 0;
68	68
69	69	static vector_ops_t *create_ops(const int size);
70	70
r243831	r243832
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 double sum(const double * v)
	98	const nl_double sum(const nl_double * v)
99	99	{
100		const double *  RESTRICT vl = v;
101		double tmp = 0.0;
	100	const nl_double *  RESTRICT vl = v;
	101	nl_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 double * RESTRICT v1, const double * RESTRICT v2, double & RESTRICT s1, double & RESTRICT s2)
	107	void sum2(const nl_double * RESTRICT v1, const nl_double * RESTRICT v2, nl_double & RESTRICT s1, nl_double & RESTRICT s2)
108	108	{
109		const double * RESTRICT v1l = v1;
110		const double * RESTRICT v2l = v2;
	109	const nl_double * RESTRICT v1l = v1;
	110	const nl_double * RESTRICT v2l = v2;
111	111	for (int i=0; i < N(); i++)
112	112	{
113	113	s1 += v1l[i];
r243831	r243832
115	115	}
116	116	}
117	117
118		void addmult(double * RESTRICT v1, const double * RESTRICT v2, const double &mult)
	118	void addmult(nl_double * RESTRICT v1, const nl_double * RESTRICT v2, const nl_double &mult)
119	119	{
120		double * RESTRICT v1l = v1;
121		const double * RESTRICT v2l = v2;
	120	nl_double * RESTRICT v1l = v1;
	121	const nl_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 double * RESTRICT v1, const double * RESTRICT v2, const double * RESTRICT v3abs, double & RESTRICT s1, double & RESTRICT s2, double & RESTRICT s3abs)
	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)
129	129	{
130		const double * RESTRICT v1l = v1;
131		const double * RESTRICT v2l = v2;
132		const double * RESTRICT v3l = v3abs;
	130	const nl_double * RESTRICT v1l = v1;
	131	const nl_double * RESTRICT v2l = v2;
	132	const nl_double * RESTRICT v3l = v3abs;
133	133	for (int i=0; i < N(); i++)
134	134	{
135	135	s1 += v1l[i];
r243831	r243832
138	138	}
139	139	}
140	140
141		const double sumabs(const double * v)
	141	const nl_double sumabs(const nl_double * v)
142	142	{
143		const double * RESTRICT vl = v;
144		double tmp = 0.0;
	143	const nl_double * RESTRICT vl = v;
	144	nl_double tmp = 0.0;
145	145	for (int i=0; i < N(); i++)
146	146	tmp += fabs(vl[i]);
147	147	return tmp;
r243831	r243832
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 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; }
	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; }
178	178
179	179	ATTR_COLD void set_pointers();
180	180
r243831	r243832
183	183	private:
184	184	plinearlist_t<netlist_terminal_t *> m_term;
185	185	plinearlist_t<int> m_net_other;
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;
	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;
190	190	};
191	191
192	192	class netlist_matrix_solver_t : public netlist_device_t
r243831	r243832
209	209	template<class C>
210	210	void solve_base(C *p);
211	211
212		ATTR_HOT double solve();
	212	ATTR_HOT nl_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; }
r243831	r243832
236	236	ATTR_HOT void update_dynamic();
237	237
238	238	// should return next time step
239		ATTR_HOT virtual double vsolve() = 0;
	239	ATTR_HOT virtual nl_double vsolve() = 0;
240	240
241	241	ATTR_COLD virtual void  add_term(int net_idx, netlist_terminal_t *term) = 0;
242	242
r243831	r243832
249	249
250	250	const netlist_solver_parameters_t &m_params;
251	251
252		ATTR_HOT inline const double current_timestep() { return m_cur_ts; }
	252	ATTR_HOT inline const nl_double current_timestep() { return m_cur_ts; }
253	253	private:
254	254
255	255	netlist_time m_last_step;
256		double m_cur_ts;
	256	nl_double m_cur_ts;
257	257	dev_list_t m_step_devices;
258	258	dev_list_t m_dynamic_devices;
259	259
r243831	r243832
279	279
280	280	ATTR_COLD void post_start();
281	281
282		ATTR_HOT inline double gmin() { return m_gmin.Value(); }
	282	ATTR_HOT inline nl_double gmin() { return m_gmin.Value(); }
283	283
284	284	protected:
285	285	ATTR_HOT void update();

branches/kale/src/emu/netlist/analog/nld_twoterm.c

r243831	r243832
16	16	set_param(1e-15, 1, 1e-15);
17	17	}
18	18
19		ATTR_COLD void netlist_generic_diode::set_param(const double Is, const double n, double gmin)
	19	ATTR_COLD void netlist_generic_diode::set_param(const nl_double Is, const nl_double n, nl_double gmin)
20	20	{
21	21	m_Is = Is;
22	22	m_n = n;
r243831	r243832
157	157
158	158	NETLIB_UPDATE_PARAM(POT)
159	159	{
160		double v = m_Dial.Value();
	160	nl_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
r243831	r243832
221	221
222	222	NETLIB_UPDATE_PARAM(D)
223	223	{
224		double Is = m_model.model_value("Is", 1e-15);
225		double n = m_model.model_value("N", 1);
	224	nl_double Is = m_model.model_value("Is", 1e-15);
	225	nl_double n = m_model.model_value("N", 1);
226	226
227	227	m_D.set_param(Is, n, netlist().gmin());
228	228	}

branches/kale/src/emu/netlist/analog/nld_twoterm.h

r243831	r243832
97	97	{
98	98	}
99	99
100		ATTR_HOT inline void set(const double G, const double V, const double I)
	100	ATTR_HOT inline void set(const nl_double G, const nl_double V, const nl_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 double deltaV() const
	107	ATTR_HOT inline nl_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(double a11, double a12, double a21, double a22, double r1, double r2)
	112	ATTR_HOT void set_mat(nl_double a11, nl_double a12, nl_double a21, nl_double a22, nl_double r1, nl_double r2)
113	113	{
114	114	/*      GO, GT, I                */
115	115	m_P.set(-a12, a11, -r1);
r243831	r243832
133	133	public:
134	134	ATTR_COLD NETLIB_NAME(R_base)() : NETLIB_NAME(twoterm)(RESISTOR) { }
135	135
136		inline void set_R(const double R)
	136	inline void set_R(const nl_double R)
137	137	{
138	138	set(1.0 / R, 0.0, 0.0);
139	139	}
r243831	r243832
171	171	public:
172	172	ATTR_COLD NETLIB_NAME(C)() : NETLIB_NAME(twoterm)(CAPACITOR) { }
173	173
174		ATTR_HOT void step_time(const double st)
	174	ATTR_HOT void step_time(const nl_double st)
175	175	{
176		const double G = m_C.Value() / st;
177		const double I = -G * deltaV();
	176	const nl_double G = m_C.Value() / st;
	177	const nl_double I = -G * deltaV();
178	178	set(G, 0.0, I);
179	179	}
180	180
r243831	r243832
198	198	public:
199	199	ATTR_COLD netlist_generic_diode();
200	200
201		ATTR_HOT inline void update_diode(const double nVd)
	201	ATTR_HOT inline void update_diode(const nl_double nVd)
202	202	{
203	203	//FIXME: Optimize cutoff case
204	204
r243831	r243832
212	212	{
213	213	m_Vd = nVd;
214	214
215		const double eVDVt = exp(m_Vd * m_VtInv);
	215	const nl_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	}
r243831	r243832
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		double a = (nVd - m_Vd) * m_VtInv;
	224	nl_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 double eVDVt = exp(m_Vd * m_VtInv);
	228	const nl_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;
r243831	r243832
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 double Is, const double n, double gmin);
	237	ATTR_COLD void set_param(const nl_double Is, const nl_double n, nl_double gmin);
238	238
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; }
	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; }
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		double m_Vd;
250		double m_Id;
251		double m_G;
	249	nl_double m_Vd;
	250	nl_double m_Id;
	251	nl_double m_G;
252	252
253		double m_Vt;
254		double m_Is;
255		double m_n;
256		double m_gmin;
	253	nl_double m_Vt;
	254	nl_double m_Is;
	255	nl_double m_n;
	256	nl_double m_gmin;
257	257
258		double m_VtInv;
259		double m_Vcrit;
	258	nl_double m_VtInv;
	259	nl_double m_Vcrit;
260	260	};
261	261
262	262	// ----------------------------------------------------------------------------------------
r243831	r243832
268	268	// add c3 and it'll be better than 1%
269	269
270	270	#if 0
271		inline double fastexp_h(const double x)
	271	inline nl_double fastexp_h(const nl_double x)
272	272	{
273		static const double ln2r = 1.442695040888963387;
274		static const double ln2  = 0.693147180559945286;
275		//static const double c3   = 0.166666666666666667;
	273	static const nl_double ln2r = 1.442695040888963387;
	274	static const nl_double ln2  = 0.693147180559945286;
	275	//static const nl_double c3   = 0.166666666666666667;
276	276
277		const double y = x * ln2r;
	277	const nl_double y = x * ln2r;
278	278	const unsigned int t = y;
279		const double z = (x - ln2 * (double) t);
280		const double zz = z * z;
281		//const double zzz = zz * z;
	279	const nl_double z = (x - ln2 * (double) t);
	280	const nl_double zz = z * z;
	281	//const nl_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 double fastexp(const double x)
	286	inline nl_double fastexp(const nl_double x)
287	287	{
288	288	if (x<0)
289	289	return 1.0 / fastexp_h(-x);

branches/kale/src/emu/netlist/devices/nld_4066.c

r243831	r243832
19	19
20	20	NETLIB_UPDATE(4066)
21	21	{
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;
	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;
27	27
28	28	if (in < low)
29	29	{

branches/kale/src/emu/netlist/devices/nld_74123.c

r243831	r243832
69	69
70	70	if (m_state == 1)
71	71	{
72		const double vLow = m_KP * TERMANALOG(m_RP.m_P);
	72	const nl_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);
r243831	r243832
78	78	}
79	79	else if (m_state == 2)
80	80	{
81		const double vHigh = TERMANALOG(m_RP.m_P) * (1.0 - m_KP);
	81	const nl_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);

branches/kale/src/emu/netlist/devices/nld_74ls629.c

r243831	r243832
104	104	{
105	105	{
106	106	// recompute
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);
	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);
111	111
112	112	/* coefficients */
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;
	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;
123	123
124	124	/* scale due to input resistance */
125	125

branches/kale/src/emu/netlist/devices/nld_cmos.h

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

branches/kale/src/emu/netlist/devices/nld_ne555.c

r243831	r243832
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 double NETLIB_NAME(NE555)::clamp(const double v, const double a, const double b)
	13	inline nl_double NETLIB_NAME(NE555)::clamp(const nl_double v, const nl_double a, const nl_double b)
14	14	{
15		double ret = v;
16		double vcc = TERMANALOG(m_R1.m_P);
	15	nl_double ret = v;
	16	nl_double vcc = TERMANALOG(m_R1.m_P);
17	17
18	18	if (ret >  vcc - a)
19	19	ret = vcc - a;
r243831	r243832
64	64	{
65	65	// FIXME: assumes GND is connected to 0V.
66	66
67		double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
	67	nl_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;

branches/kale/src/emu/netlist/devices/nld_ne555.h

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

branches/kale/src/emu/netlist/devices/nld_r2r_dac.c

r243831	r243832
32	32
33	33	update_dev();
34	34
35		double V = m_VIN.Value() / (double) (1 << m_num.Value()) * (double) m_val.Value();
	35	nl_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	}

branches/kale/src/emu/netlist/devices/nld_system.c

r243831	r243832
118	118	if (state != m_last_state)
119	119	{
120	120	m_last_state = state;
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;
	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;
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())

branches/kale/src/emu/netlist/nl_base.c

r243831	r243832
170	170	netlist_object_t::save_register();
171	171	}
172	172
173		ATTR_HOT const double netlist_base_t::gmin() const
	173	ATTR_HOT const nl_double netlist_base_t::gmin() const
174	174	{
175	175	return solver()->gmin();
176	176	}
r243831	r243832
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);
455	456	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_int_t &param, const int initialVal);
456	457	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_logic_t &param, const int initialVal);
457	458	template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_str_t &param, const char * const initialVal);
r243831	r243832
874	875	net().as_analog().m_cur_Analog = 0.98;
875	876	}
876	877
877		ATTR_COLD void netlist_analog_output_t::initial(const double val)
	878	ATTR_COLD void netlist_analog_output_t::initial(const nl_double val)
878	879	{
879	880	net().as_analog().m_cur_Analog = val * 0.99;
880	881	}
r243831	r243832
931	932	}
932	933
933	934
934		ATTR_COLD double netlist_param_model_t::model_value(const pstring &entity, const double defval) const
	935	ATTR_COLD nl_double netlist_param_model_t::model_value(const pstring &entity, const nl_double defval) const
935	936	{
936	937	pstring tmp = this->Value();
937	938	// .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)
r243831	r243832
945	946	if (pequal < 0)
946	947	netlist().error("parameter %s misformat in model %s temp %s\n", entity.cstr(), Value().cstr(), tmp.cstr());
947	948	tmp = tmp.substr(pequal+1);
948		double factor = 1.0;
	949	nl_double factor = 1.0;
949	950	switch (*(tmp.right(1).cstr()))
950	951	{
951	952	case 'm': factor = 1e-3; break;

branches/kale/src/emu/netlist/nl_base.h

r243831	r243832
272	272
273	273	struct netlist_logic_family_desc_t
274	274	{
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;
	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;
281	281	};
282	282
283	283	/* Terminals inherit the family description from the netlist_device
r243831	r243832
474	474
475	475	ATTR_COLD netlist_terminal_t();
476	476
477		double *m_Idr1; // drive current
478		double *m_go1;  // conductance for Voltage from other term
479		double *m_gt1;  // conductance for total conductance
	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
480	480
481		ATTR_HOT inline void set(const double G)
	481	ATTR_HOT inline void set(const nl_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 double GO, const double GT)
	488	ATTR_HOT inline void set(const nl_double GO, const nl_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 double GO, const double GT, const double I)
	495	ATTR_HOT inline void set(const nl_double GO, const nl_double GT, const nl_double I)
496	496	{
497	497	set_ptr(m_Idr1, I);
498	498	set_ptr(m_go1, GO);
r243831	r243832
509	509
510	510	ATTR_COLD virtual void reset();
511	511	private:
512		inline void set_ptr(double *ptr, const double val)
	512	inline void set_ptr(nl_double *ptr, const nl_double val)
513	513	{
514	514	if (ptr != NULL)
515	515	*ptr = val;
r243831	r243832
586	586	ATTR_COLD netlist_analog_input_t()
587	587	: netlist_input_t(INPUT, ANALOG) { }
588	588
589		ATTR_HOT inline const double Q_Analog() const;
	589	ATTR_HOT inline const nl_double Q_Analog() const;
590	590	};
591	591
592	592	//#define INPVAL(_x) (_x).Q()
r243831	r243832
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		double m_cur_Analog;
	664	nl_double m_cur_Analog;
665	665
666	666	};
667	667
r243831	r243832
736	736	ATTR_COLD netlist_analog_net_t();
737	737	ATTR_COLD virtual ~netlist_analog_net_t() { };
738	738
739		ATTR_HOT inline const double Q_Analog() const
	739	ATTR_HOT inline const nl_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 double &Q_Analog_state_ptr()
	746	ATTR_COLD inline nl_double &Q_Analog_state_ptr()
747	747	{
748	748	//nl_assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
749	749	nl_assert(family() == ANALOG);
r243831	r243832
764	764	private:
765	765
766	766	public:
767		double m_DD_n_m_1;
768		double m_h_n_m_1;
	767	nl_double m_DD_n_m_1;
	768	nl_double m_h_n_m_1;
769	769
770	770	//FIXME: needed by current solver code
771	771	netlist_matrix_solver_t *m_solver;
r243831	r243832
831	831
832	832	ATTR_COLD netlist_analog_output_t();
833	833
834		ATTR_COLD void initial(const double val);
	834	ATTR_COLD void initial(const nl_double val);
835	835
836		ATTR_HOT inline void set_Q(const double newQ);
	836	ATTR_HOT inline void set_Q(const nl_double newQ);
837	837
838	838	netlist_analog_net_t *m_proxied_net; // only for proxy nets in analog input logic
839	839
r243831	r243832
876	876	public:
877	877	ATTR_COLD netlist_param_double_t();
878	878
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;   }
	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;   }
882	882
883	883	protected:
884	884	ATTR_COLD virtual void save_register()
r243831	r243832
888	888	}
889	889
890	890	private:
891		double m_param;
	891	nl_double m_param;
892	892	};
893	893
894	894	class netlist_param_int_t : public netlist_param_t
r243831	r243832
946	946	ATTR_HOT inline const pstring &Value() const     { return m_param;     }
947	947
948	948	/* these should be cached! */
949		ATTR_COLD double model_value(const pstring &entity, const double defval = 0.0) const;
	949	ATTR_COLD nl_double model_value(const pstring &entity, const nl_double defval = 0.0) const;
950	950	ATTR_COLD const pstring model_type() const;
951	951
952	952	private:
r243831	r243832
997	997	out.set_Q(val, delay);
998	998	}
999	999
1000		ATTR_HOT inline const double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
	1000	ATTR_HOT inline const nl_double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); }
1001	1001
1002		ATTR_HOT inline const double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
	1002	ATTR_HOT inline const nl_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 double val)
	1004	ATTR_HOT inline void OUTANALOG(netlist_analog_output_t &out, const nl_double val)
1005	1005	{
1006	1006	out.set_Q(val);
1007	1007	}
r243831	r243832
1010	1010
1011	1011	ATTR_HOT virtual void dec_active() {  }
1012	1012
1013		ATTR_HOT virtual void step_time(const double st) { }
	1013	ATTR_HOT virtual void step_time(const nl_double st) { }
1014	1014	ATTR_HOT virtual void update_terminals() { }
1015	1015
1016	1016
r243831	r243832
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 double gmin() const;
	1123	ATTR_HOT const nl_double gmin() const;
1124	1124
1125	1125	ATTR_HOT inline void push_to_queue(netlist_net_t *out, const netlist_time attime)
1126	1126	{
r243831	r243832
1251	1251	}
1252	1252	}
1253	1253
1254		ATTR_HOT inline void netlist_param_double_t::setTo(const double param)
	1254	ATTR_HOT inline void netlist_param_double_t::setTo(const nl_double param)
1255	1255	{
1256	1256	if (m_param != param)
1257	1257	{
r243831	r243832
1356	1356	return net().as_logic().Q();
1357	1357	}
1358	1358
1359		ATTR_HOT inline const double netlist_analog_input_t::Q_Analog() const
	1359	ATTR_HOT inline const nl_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 double newQ)
	1364	ATTR_HOT inline void netlist_analog_output_t::set_Q(const nl_double newQ)
1365	1365	{
1366	1366	if (newQ != net().as_analog().m_cur_Analog)
1367	1367	{

branches/kale/src/emu/netlist/nl_config.h

r243831	r243832
49	49
50	50	#define NETLIST_GMIN_DEFAULT    (1e-9)
51	51
	52	//typedef double   nl_double;
	53
	54	#define nl_double double
	55
52	56	//============================================================
53	57	//  DEBUGGING
54	58	//============================================================

branches/kale/src/emu/netlist/nl_dice_compat.h

r243831	r243832
30	30	struct Mono555Desc
31	31	{
32	32	public:
33		double r, c;
	33	nl_double r, c;
34	34
35		Mono555Desc(double res, double cap) : r(res), c(cap) { }
	35	Mono555Desc(nl_double res, nl_double cap) : r(res), c(cap) { }
36	36	};
37	37
38	38	struct SeriesRCDesc
39	39	{
40	40	public:
41		double r, c;
	41	nl_double r, c;
42	42
43		SeriesRCDesc(double res, double cap) : r(res), c(cap) { }
	43	SeriesRCDesc(nl_double res, nl_double cap) : r(res), c(cap) { }
44	44	};
45	45
46	46	#define CHIP_555_Mono(_name,  _pdesc)   \

branches/kale/src/emu/netlist/nl_parser.c

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

branches/kale/src/emu/netlist/nl_parser.h

r243831	r243832
160	160	virtual void verror(pstring msg, int line_num, pstring line);
161	161	private:
162	162
163		double eval_param(const token_t tok);
	163	nl_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;

branches/kale/src/emu/netlist/pstate.c

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

branches/kale/src/emu/netlist/pstate.h

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

branches/kale/src/emu/netlist/pstring.c

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

branches/kale/src/emu/netlist/pstring.h

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

branches/kale/src/mame/includes/mario.h

r243831	r243832
3	3
4	4	#include "machine/z80dma.h"
5	5
6		#define OLD_SOUND   (1)
	6	#define OLD_SOUND   (0)
7	7
8	8	#if !OLD_SOUND
9	9	#include "machine/netlist.h"

https://github.com/mamedev/mame/commit/29583a20e8e6506f3c1b180bd6e8ad5005723103

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team