Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-16 13:34:55 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Leading underscore massacre. (nw)

Browse Source
This commit is contained in:
couriersud 2016-05-26 21:29:41 +02:00
parent fd62273a87
commit 02e3213897
70 changed files with 885 additions and 885 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/lib/netlist/analog/nld_bjt.h
View File

@ -15,13 +15,13 @@
// Macros
// -----------------------------------------------------------------------------
#define QBJT_SW(_name, _model) \
NET_REGISTER_DEV(QBJT_SW, _name) \
NETDEV_PARAMI(_name, MODEL, _model)
#define QBJT_SW(name, model) \
NET_REGISTER_DEV(QBJT_SW, name) \
NETDEV_PARAMI(name, MODEL, model)
#define QBJT_EB(_name, _model) \
NET_REGISTER_DEV(QBJT_EB, _name) \
NETDEV_PARAMI(_name, MODEL, _model)
#define QBJT_EB(name, model) \
NET_REGISTER_DEV(QBJT_EB, name) \
NETDEV_PARAMI(name, MODEL, model)
NETLIB_NAMESPACE_DEVICES_START()

16
src/lib/netlist/analog/nld_fourterm.h
View File

@ -16,17 +16,17 @@
// Macros
// ----------------------------------------------------------------------------------------
#define VCCS(_name) \
NET_REGISTER_DEV(VCCS, _name)
#define VCCS(name) \
NET_REGISTER_DEV(VCCS, name)
#define CCCS(_name) \
NET_REGISTER_DEV(CCCS, _name)
#define CCCS(name) \
NET_REGISTER_DEV(CCCS, name)
#define VCVS(_name) \
NET_REGISTER_DEV(VCVS, _name)
#define VCVS(name) \
NET_REGISTER_DEV(VCVS, name)
#define LVCCS(_name) \
NET_REGISTER_DEV(LVCCS, _name)
#define LVCCS(name) \
NET_REGISTER_DEV(LVCCS, name)
NETLIB_NAMESPACE_DEVICES_START()

10
src/lib/netlist/analog/nld_opamps.h
View File

@ -19,12 +19,12 @@
// Macros
// ----------------------------------------------------------------------------------------
#define OPAMP(_name, _model) \
NET_REGISTER_DEV(OPAMP, _name) \
NETDEV_PARAMI(_name, MODEL, _model)
#define OPAMP(name, model) \
NET_REGISTER_DEV(OPAMP, name) \
NETDEV_PARAMI(name, MODEL, model)
#define LM3900(_name) \
SUBMODEL(opamp_lm3900, _name)
#define LM3900(name) \
SUBMODEL(opamp_lm3900, name)
// ----------------------------------------------------------------------------------------
// Devices ...

8
src/lib/netlist/analog/nld_switches.h
View File

@ -17,11 +17,11 @@
// Macros
// ----------------------------------------------------------------------------------------
#define SWITCH(_name) \
NET_REGISTER_DEV(SWITCH, _name)
#define SWITCH(name) \
NET_REGISTER_DEV(SWITCH, name)
#define SWITCH2(_name) \
NET_REGISTER_DEV(SWITCH2, _name)
#define SWITCH2(name) \
NET_REGISTER_DEV(SWITCH2, name)
// ----------------------------------------------------------------------------------------
// Devices ...

42
src/lib/netlist/analog/nld_twoterm.h
View File

@ -39,36 +39,36 @@
// Macros
// -----------------------------------------------------------------------------
#define RES(_name, _R) \
NET_REGISTER_DEV(RES, _name) \
NETDEV_PARAMI(_name, R, _R)
#define RES(name, p_R) \
NET_REGISTER_DEV(RES, name) \
NETDEV_PARAMI(name, R, p_R)
#define POT(_name, _R) \
NET_REGISTER_DEV(POT, _name) \
NETDEV_PARAMI(_name, R, _R)
#define POT(name, p_R) \
NET_REGISTER_DEV(POT, name) \
NETDEV_PARAMI(name, R, p_R)
/* Does not have pin 3 connected */
#define POT2(_name, _R) \
NET_REGISTER_DEV(POT2, _name) \
NETDEV_PARAMI(_name, R, _R)
#define POT2(name, p_R) \
NET_REGISTER_DEV(POT2, name) \
NETDEV_PARAMI(name, R, p_R)
#define CAP(_name, _C) \
NET_REGISTER_DEV(CAP, _name) \
NETDEV_PARAMI(_name, C, _C)
#define CAP(name, p_C) \
NET_REGISTER_DEV(CAP, name) \
NETDEV_PARAMI(name, C, p_C)
/* Generic Diode */
#define DIODE(_name, _model) \
NET_REGISTER_DEV(DIODE, _name) \
NETDEV_PARAMI(_name, MODEL, _model)
#define DIODE(name, model) \
NET_REGISTER_DEV(DIODE, name) \
NETDEV_PARAMI(name, MODEL, model)
#define VS(_name, _V) \
NET_REGISTER_DEV(VS, _name) \
NETDEV_PARAMI(_name, V, _V)
#define VS(name, pV) \
NET_REGISTER_DEV(VS, name) \
NETDEV_PARAMI(name, V, pV)
#define CS(_name, _I) \
NET_REGISTER_DEV(CS, _name) \
NETDEV_PARAMI(_name, I, _I)
#define CS(name, pI) \
NET_REGISTER_DEV(CS, name) \
NETDEV_PARAMI(name, I, pI)
// -----------------------------------------------------------------------------
// Generic macros

6
src/lib/netlist/devices/net_lib.cpp
View File

@ -58,8 +58,8 @@ NETLIST_END()
#define xstr(s) # s
#define ENTRY1(_nic, _name, _defparam) factory.register_device<_nic>( # _name, xstr(_nic), _defparam );
#define ENTRY(_nic, _name, _defparam) ENTRY1(NETLIB_NAME(_nic), _name, _defparam)
#define ENTRY1(nic, name, defparam) factory.register_device<nic>( # name, xstr(nic), defparam );
#define ENTRY(nic, name, defparam) ENTRY1(NETLIB_NAME(nic), name, defparam)
NETLIB_NAMESPACE_DEVICES_START()
@ -119,7 +119,7 @@ void initialize_factory(factory_list_t &factory)
ENTRY(9316, TTL_9316, "+CLK,ENP,ENT,CLRQ,LOADQ,A,B,C,D")
ENTRY(CD4020, CD4020, "")
ENTRY(CD4066_GATE, CD4066_GATE, "")
/* entries with suffix _WI are legacy only */
/* entries with suffix WI are legacy only */
ENTRY(CD4020, CD4020_WI, "+IP,RESET,VDD,VSS")
//ENTRY(4066, CD_4066, "+A,B")
ENTRY(NE555, NE555, "-")

16
src/lib/netlist/devices/nld_4020.h
View File

@ -31,15 +31,15 @@
#include "nld_cmos.h"
/* FIXME: only used in mario.c */
#define CD4020_WI(_name, _IP, _RESET, _VDD, _VSS) \
NET_REGISTER_DEV(CD4020_WI, _name) \
NET_CONNECT(_name, IP, _IP) \
NET_CONNECT(_name, RESET, _RESET) \
NET_CONNECT(_name, VDD, _VDD) \
NET_CONNECT(_name, VSS, _VSS)
#define CD4020_WI(name, cIP, cRESET, cVDD, cVSS) \
NET_REGISTER_DEV(CD4020_WI, name) \
NET_CONNECT(name, IP, cIP) \
NET_CONNECT(name, RESET, cRESET) \
NET_CONNECT(name, VDD, cVDD) \
NET_CONNECT(name, VSS, cVSS)
#define CD4020(_name) \
NET_REGISTER_DEV(CD4020, _name)
#define CD4020(name) \
NET_REGISTER_DEV(CD4020, name)
NETLIB_NAMESPACE_DEVICES_START()

4
src/lib/netlist/devices/nld_4066.h
View File

@ -27,8 +27,8 @@
#include "nl_base.h"
#include "nld_cmos.h"
#define CD4066_GATE(_name) \
NET_REGISTER_DEV(CD4066_GATE, _name)
#define CD4066_GATE(name) \
NET_REGISTER_DEV(CD4066_GATE, name)
NETLIB_NAMESPACE_DEVICES_START()

20
src/lib/netlist/devices/nld_74107.h
View File

@ -61,18 +61,18 @@
#include "nl_base.h"
#define TTL_74107A(_name, _CLK, _J, _K, _CLRQ) \
NET_REGISTER_DEV(TTL_74107A, _name) \
NET_CONNECT(_name, CLK, _CLK) \
NET_CONNECT(_name, J, _J) \
NET_CONNECT(_name, K, _K) \
NET_CONNECT(_name, CLRQ, _CLRQ)
#define TTL_74107A(name, cCLK, cJ, cK, cCLRQ) \
NET_REGISTER_DEV(TTL_74107A, name) \
NET_CONNECT(name, CLK, cCLK) \
NET_CONNECT(name, J, cJ) \
NET_CONNECT(name, K, cK) \
NET_CONNECT(name, CLRQ, cCLRQ)
#define TTL_74107(_name, _CLK, _J, _K, _CLRQ) \
TTL_74107A(_name, _CLK, _J, _K, _CLRQ)
#define TTL_74107(name, cCLK, cJ, cK, cCLRQ) \
TTL_74107A(name, cCLK, cJ, cK, cCLRQ)
#define TTL_74107_DIP(_name) \
NET_REGISTER_DEV(TTL_74107_DIP, _name)
#define TTL_74107_DIP(name) \
NET_REGISTER_DEV(TTL_74107_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

16
src/lib/netlist/devices/nld_74123.h
View File

@ -53,8 +53,8 @@
#include "nld_system.h"
#include "analog/nld_twoterm.h"
#define TTL_74123(_name) \
NET_REGISTER_DEV(TTL_74123, _name)
#define TTL_74123(name) \
NET_REGISTER_DEV(TTL_74123, name)
NETLIB_NAMESPACE_DEVICES_START()
@ -126,8 +126,8 @@ public:
param_double_t m_RI;
};
#define TTL_74123_DIP(_name) \
NET_REGISTER_DEV(TTL_74123_DIP, _name)
#define TTL_74123_DIP(name) \
NET_REGISTER_DEV(TTL_74123_DIP, name)
NETLIB_OBJECT(74123_dip)
{
@ -166,8 +166,8 @@ private:
* THe 9602 uses an OR gate instead of an AND gate.
*/
#define TTL_9602_DIP(_name) \
NET_REGISTER_DEV(TTL_9602_DIP, _name)
#define TTL_9602_DIP(name) \
NET_REGISTER_DEV(TTL_9602_DIP, name)
NETLIB_OBJECT(9602_dip)
{
@ -206,8 +206,8 @@ private:
* The CD4538 is pretty similar to the 9602
*/
#define CD4538_DIP(_name) \
NET_REGISTER_DEV(CD4538_DIP, _name)
#define CD4538_DIP(name) \
NET_REGISTER_DEV(CD4538_DIP, name)
NETLIB_OBJECT(4538_dip)
{

22
src/lib/netlist/devices/nld_74153.h
View File

@ -47,18 +47,18 @@
#include "nl_base.h"
#define TTL_74153(_name, _C0, _C1, _C2, _C3, _A, _B, _G) \
NET_REGISTER_DEV(TTL_74153, _name) \
NET_CONNECT(_name, C0, _C0) \
NET_CONNECT(_name, C1, _C1) \
NET_CONNECT(_name, C2, _C2) \
NET_CONNECT(_name, C3, _C3) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B) \
NET_CONNECT(_name, G, _G)
#define TTL_74153(name, cC0, cC1, cC2, cC3, cA, cB, cG) \
NET_REGISTER_DEV(TTL_74153, name) \
NET_CONNECT(name, C0, cC0) \
NET_CONNECT(name, C1, cC1) \
NET_CONNECT(name, C2, cC2) \
NET_CONNECT(name, C3, cC3) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB) \
NET_CONNECT(name, G, cG)
#define TTL_74153_DIP(_name) \
NET_REGISTER_DEV(TTL_74153_DIP, _name)
#define TTL_74153_DIP(name) \
NET_REGISTER_DEV(TTL_74153_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_74175.h
View File

@ -38,10 +38,10 @@
#include "nl_base.h"
#define TTL_74175(_name) \
NET_REGISTER_DEV(TTL_74175, _name)
#define TTL_74175_DIP(_name) \
NET_REGISTER_DEV(TTL_74175_DIP, _name)
#define TTL_74175(name) \
NET_REGISTER_DEV(TTL_74175, name)
#define TTL_74175_DIP(name) \
NET_REGISTER_DEV(TTL_74175_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_74192.h
View File

@ -32,11 +32,11 @@
#include "nl_base.h"
#include "nld_9316.h"
#define TTL_74192(_name) \
NET_REGISTER_DEV(TTL_74192, _name)
#define TTL_74192(name) \
NET_REGISTER_DEV(TTL_74192, name)
#define TTL_74192_DIP(_name) \
NET_REGISTER_DEV(TTL_74192_DIP, _name)
#define TTL_74192_DIP(name) \
NET_REGISTER_DEV(TTL_74192_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_74193.h
View File

@ -28,11 +28,11 @@
#include "nl_base.h"
#define TTL_74193(_name) \
NET_REGISTER_DEV(TTL_74193, _name)
#define TTL_74193(name) \
NET_REGISTER_DEV(TTL_74193, name)
#define TTL_74193_DIP(_name) \
NET_REGISTER_DEV(TTL_74193_DIP, _name)
#define TTL_74193_DIP(name) \
NET_REGISTER_DEV(TTL_74193_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

4
src/lib/netlist/devices/nld_74279.h
View File

@ -38,8 +38,8 @@
#include "nld_truthtable.h"
#define TTL_74279_DIP(_name) \
NET_REGISTER_DEV(TTL_74279_DIP, _name)
#define TTL_74279_DIP(name) \
NET_REGISTER_DEV(TTL_74279_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

22
src/lib/netlist/devices/nld_7448.h
View File

@ -27,18 +27,18 @@
#include "nl_base.h"
#include "nld_truthtable.h"
#define TTL_7448(_name, _A0, _A1, _A2, _A3, _LTQ, _BIQ, _RBIQ) \
NET_REGISTER_DEV(TTL_7448, _name) \
NET_CONNECT(_name, A, _A0) \
NET_CONNECT(_name, B, _A1) \
NET_CONNECT(_name, C, _A2) \
NET_CONNECT(_name, D, _A3) \
NET_CONNECT(_name, LTQ, _LTQ) \
NET_CONNECT(_name, BIQ, _BIQ) \
NET_CONNECT(_name, RBIQ, _RBIQ)
#define TTL_7448(name, cA0, cA1, cA2, cA3, cLTQ, cBIQ, cRBIQ) \
NET_REGISTER_DEV(TTL_7448, name) \
NET_CONNECT(name, A, cA0) \
NET_CONNECT(name, B, cA1) \
NET_CONNECT(name, C, cA2) \
NET_CONNECT(name, D, cA3) \
NET_CONNECT(name, LTQ, cLTQ) \
NET_CONNECT(name, BIQ, cBIQ) \
NET_CONNECT(name, RBIQ, cRBIQ)
#define TTL_7448_DIP(_name) \
NET_REGISTER_DEV(TTL_7448_DIP, _name)
#define TTL_7448_DIP(name) \
NET_REGISTER_DEV(TTL_7448_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

16
src/lib/netlist/devices/nld_7450.h
View File

@ -26,15 +26,15 @@
#include "nl_base.h"
#define TTL_7450_ANDORINVERT(_name, _I1, _I2, _I3, _I4) \
NET_REGISTER_DEV(TTL_7450_ANDORINVERT, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3) \
NET_CONNECT(_name, D, _I4)
#define TTL_7450_ANDORINVERT(name, cI1, cI2, cI3, cI4) \
NET_REGISTER_DEV(TTL_7450_ANDORINVERT, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3) \
NET_CONNECT(name, D, cI4)
#define TTL_7450_DIP(_name) \
NET_REGISTER_DEV(TTL_7450_DIP, _name)
#define TTL_7450_DIP(name) \
NET_REGISTER_DEV(TTL_7450_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

16
src/lib/netlist/devices/nld_7474.h
View File

@ -44,15 +44,15 @@
#include "nl_base.h"
#define TTL_7474(_name, _CLK, _D, _CLRQ, _PREQ) \
NET_REGISTER_DEV(TTL_7474, _name) \
NET_CONNECT(_name, CLK, _CLK) \
NET_CONNECT(_name, D, _D) \
NET_CONNECT(_name, CLRQ, _CLRQ) \
NET_CONNECT(_name, PREQ, _PREQ)
#define TTL_7474(name, cCLK, cD, cCLRQ, cPREQ) \
NET_REGISTER_DEV(TTL_7474, name) \
NET_CONNECT(name, CLK, cCLK) \
NET_CONNECT(name, D, cD) \
NET_CONNECT(name, CLRQ, cCLRQ) \
NET_CONNECT(name, PREQ, cPREQ)
#define TTL_7474_DIP(_name) \
NET_REGISTER_DEV(TTL_7474_DIP, _name)
#define TTL_7474_DIP(name) \
NET_REGISTER_DEV(TTL_7474_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

26
src/lib/netlist/devices/nld_7483.h
View File

@ -29,20 +29,20 @@
#include "nl_base.h"
#define TTL_7483(_name, _A1, _A2, _A3, _A4, _B1, _B2, _B3, _B4, _CI) \
NET_REGISTER_DEV(TTL_7483, _name) \
NET_CONNECT(_name, A1, _A1) \
NET_CONNECT(_name, A2, _A2) \
NET_CONNECT(_name, A3, _A3) \
NET_CONNECT(_name, A4, _A4) \
NET_CONNECT(_name, B1, _B1) \
NET_CONNECT(_name, B2, _B2) \
NET_CONNECT(_name, B3, _B3) \
NET_CONNECT(_name, B4, _B4) \
NET_CONNECT(_name, C0, _CI)
#define TTL_7483(name, cA1, cA2, cA3, cA4, cB1, cB2, cB3, cB4, cCI) \
NET_REGISTER_DEV(TTL_7483, name) \
NET_CONNECT(name, A1, cA1) \
NET_CONNECT(name, A2, cA2) \
NET_CONNECT(name, A3, cA3) \
NET_CONNECT(name, A4, cA4) \
NET_CONNECT(name, B1, cB1) \
NET_CONNECT(name, B2, cB2) \
NET_CONNECT(name, B3, cB3) \
NET_CONNECT(name, B4, cB4) \
NET_CONNECT(name, C0, cCI)
#define TTL_7483_DIP(_name) \
NET_REGISTER_DEV(TTL_7483_DIP, _name)
#define TTL_7483_DIP(name) \
NET_REGISTER_DEV(TTL_7483_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

20
src/lib/netlist/devices/nld_7490.h
View File

@ -57,17 +57,17 @@
#include "nl_base.h"
#define TTL_7490(_name, _A, _B, _R1, _R2, _R91, _R92) \
NET_REGISTER_DEV(TTL_7490, _name) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B) \
NET_CONNECT(_name, R1, _R1) \
NET_CONNECT(_name, R2, _R2) \
NET_CONNECT(_name, R91, _R91) \
NET_CONNECT(_name, R92, _R92)
#define TTL_7490(name, cA, cB, cR1, cR2, cR91, cR92) \
NET_REGISTER_DEV(TTL_7490, name) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB) \
NET_CONNECT(name, R1, cR1) \
NET_CONNECT(name, R2, cR2) \
NET_CONNECT(name, R91, cR91) \
NET_CONNECT(name, R92, cR92)
#define TTL_7490_DIP(_name) \
NET_REGISTER_DEV(TTL_7490_DIP, _name)
#define TTL_7490_DIP(name) \
NET_REGISTER_DEV(TTL_7490_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

16
src/lib/netlist/devices/nld_7493.h
View File

@ -59,15 +59,15 @@
#include "nl_base.h"
#define TTL_7493(_name, _CLKA, _CLKB, _R1, _R2) \
NET_REGISTER_DEV(TTL_7493, _name) \
NET_CONNECT(_name, CLKA, _CLKA) \
NET_CONNECT(_name, CLKB, _CLKB) \
NET_CONNECT(_name, R1, _R1) \
NET_CONNECT(_name, R2, _R2)
#define TTL_7493(name, cCLKA, cCLKB, cR1, cR2) \
NET_REGISTER_DEV(TTL_7493, name) \
NET_CONNECT(name, CLKA, cCLKA) \
NET_CONNECT(name, CLKB, cCLKB) \
NET_CONNECT(name, R1, cR1) \
NET_CONNECT(name, R2, cR2)
#define TTL_7493_DIP(_name) \
NET_REGISTER_DEV(TTL_7493_DIP, _name)
#define TTL_7493_DIP(name) \
NET_REGISTER_DEV(TTL_7493_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

14
src/lib/netlist/devices/nld_74ls629.h
View File

@ -31,14 +31,14 @@
#include "nl_base.h"
#include "analog/nld_twoterm.h"
#define SN74LS629(_name, _cap) \
NET_REGISTER_DEV(SN74LS629, _name) \
NETDEV_PARAMI(_name, CAP, _cap)
#define SN74LS629(name, p_cap) \
NET_REGISTER_DEV(SN74LS629, name) \
NETDEV_PARAMI(name, CAP, p_cap)
#define SN74LS629_DIP(_name, _cap1, _cap2) \
NET_REGISTER_DEV(SN74LS629_DIP, _name) \
NETDEV_PARAMI(_name, 1.CAP, _cap1) \
NETDEV_PARAMI(_name, 2.CAP, _cap2)
#define SN74LS629_DIP(name, p_cap1, p_cap2) \
NET_REGISTER_DEV(SN74LS629_DIP, name) \
NETDEV_PARAMI(name, 1.CAP, p_cap1) \
NETDEV_PARAMI(name, 2.CAP, p_cap2)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_82S16.h
View File

@ -26,10 +26,10 @@
#include "nl_base.h"
#define TTL_82S16(_name) \
NET_REGISTER_DEV(TTL_82S16, _name)
#define TTL_82S16_DIP(_name) \
NET_REGISTER_DEV(TTL_82S16_DIP, _name)
#define TTL_82S16(name) \
NET_REGISTER_DEV(TTL_82S16, name)
#define TTL_82S16_DIP(name) \
NET_REGISTER_DEV(TTL_82S16_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

26
src/lib/netlist/devices/nld_9310.h
View File

@ -47,20 +47,20 @@
#include "nl_base.h"
#define TTL_9310(_name, _CLK, _ENP, _ENT, _CLRQ, _LOADQ, _A, _B, _C, _D) \
NET_REGISTER_DEV(TTL_9310, _name) \
NET_CONNECT(_name, CLK, _CLK) \
NET_CONNECT(_name, ENP, _ENP) \
NET_CONNECT(_name, ENT, _ENT) \
NET_CONNECT(_name, CLRQ, _CLRQ) \
NET_CONNECT(_name, LOADQ,_LOADQ) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B) \
NET_CONNECT(_name, C, _C) \
NET_CONNECT(_name, D, _D)
#define TTL_9310(name, cCLK, cENP, cENT, cCLRQ, cLOADQ, cA, cB, cC, cD) \
NET_REGISTER_DEV(TTL_9310, name) \
NET_CONNECT(name, CLK, cCLK) \
NET_CONNECT(name, ENP, cENP) \
NET_CONNECT(name, ENT, cENT) \
NET_CONNECT(name, CLRQ, cCLRQ) \
NET_CONNECT(name, LOADQ,_LOADQ) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB) \
NET_CONNECT(name, C, cC) \
NET_CONNECT(name, D, cD)
#define TTL_9310_DIP(_name) \
NET_REGISTER_DEV(TTL_9310_DIP, _name)
#define TTL_9310_DIP(name) \
NET_REGISTER_DEV(TTL_9310_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_9312.h
View File

@ -39,11 +39,11 @@
#include "nld_truthtable.h"
#define TTL_9312(_name) \
NET_REGISTER_DEV(TTL_9312, _name)
#define TTL_9312(name) \
NET_REGISTER_DEV(TTL_9312, name)
#define TTL_9312_DIP(_name) \
NET_REGISTER_DEV(TTL_9312_DIP, _name)
#define TTL_9312_DIP(name) \
NET_REGISTER_DEV(TTL_9312_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

26
src/lib/netlist/devices/nld_9316.h
View File

@ -51,20 +51,20 @@
#include "nl_base.h"
#define TTL_9316(_name, _CLK, _ENP, _ENT, _CLRQ, _LOADQ, _A, _B, _C, _D) \
NET_REGISTER_DEV(TTL_9316, _name) \
NET_CONNECT(_name, CLK, _CLK) \
NET_CONNECT(_name, ENP, _ENP) \
NET_CONNECT(_name, ENT, _ENT) \
NET_CONNECT(_name, CLRQ, _CLRQ) \
NET_CONNECT(_name, LOADQ,_LOADQ) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B) \
NET_CONNECT(_name, C, _C) \
NET_CONNECT(_name, D, _D)
#define TTL_9316(name, cCLK, cENP, cENT, cCLRQ, cLOADQ, cA, cB, cC, cD) \
NET_REGISTER_DEV(TTL_9316, name) \
NET_CONNECT(name, CLK, cCLK) \
NET_CONNECT(name, ENP, cENP) \
NET_CONNECT(name, ENT, cENT) \
NET_CONNECT(name, CLRQ, cCLRQ) \
NET_CONNECT(name, LOADQ,_LOADQ) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB) \
NET_CONNECT(name, C, cC) \
NET_CONNECT(name, D, cD)
#define TTL_9316_DIP(_name) \
NET_REGISTER_DEV(TTL_9316_DIP, _name)
#define TTL_9316_DIP(name) \
NET_REGISTER_DEV(TTL_9316_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_legacy.h
View File

@ -21,11 +21,11 @@ NETLIB_NAMESPACE_DEVICES_START()
// Macros
// ----------------------------------------------------------------------------------------
#define NETDEV_RSFF(_name) \
NET_REGISTER_DEV(NETDEV_RSFF, _name)
#define NETDEV_RSFF(name) \
NET_REGISTER_DEV(NETDEV_RSFF, name)
#define NETDEV_DELAY(_name) \
NET_REGISTER_DEV(NETDEV_DELAY, _name)
#define NETDEV_DELAY(name) \
NET_REGISTER_DEV(NETDEV_DELAY, name)
// ----------------------------------------------------------------------------------------
// Devices ...

14
src/lib/netlist/devices/nld_log.h
View File

@ -23,14 +23,14 @@
#include "plib/pstream.h"
#include "plib/pfmtlog.h"
#define LOG(_name, _I) \
NET_REGISTER_DEV(??PG, _name) \
NET_CONNECT(_name, I, _I)
#define LOG(name, cI) \
NET_REGISTER_DEV(??PG, name) \
NET_CONNECT(name, I, cI)
#define LOGD(_name, _I, _I2) \
NET_REGISTER_DEV(LOGD, _name) \
NET_CONNECT(_name, I, _I) \
NET_CONNECT(_name, I2, _I2)
#define LOGD(name, cI, cI2) \
NET_REGISTER_DEV(LOGD, name) \
NET_CONNECT(name, I, cI) \
NET_CONNECT(name, I2, cI2)
NETLIB_NAMESPACE_DEVICES_START()

4
src/lib/netlist/devices/nld_mm5837.h
View File

@ -22,8 +22,8 @@
#include "nl_base.h"
#include "analog/nld_twoterm.h"
#define MM5837_DIP(_name) \
NET_REGISTER_DEV(MM5837_DIP, _name)
#define MM5837_DIP(name) \
NET_REGISTER_DEV(MM5837_DIP, name)
NETLIB_NAMESPACE_DEVICES_START()

8
src/lib/netlist/devices/nld_ne555.h
View File

@ -22,8 +22,8 @@
#include "nl_base.h"
#include "analog/nld_twoterm.h"
#define NE555(_name) \
NET_REGISTER_DEV(NE555, _name)
#define NE555(name) \
NET_REGISTER_DEV(NE555, name)
NETLIB_NAMESPACE_DEVICES_START()
@ -77,8 +77,8 @@ private:
};
#define NE555_DIP(_name) \
NET_REGISTER_DEV(NE555_DIP, _name)
#define NE555_DIP(name) \
NET_REGISTER_DEV(NE555_DIP, name)
NETLIB_OBJECT_DERIVED(NE555_dip, NE555)
{

10
src/lib/netlist/devices/nld_r2r_dac.h
View File

@ -49,11 +49,11 @@
#include "nl_base.h"
#include "analog/nld_twoterm.h"
#define R2R_DAC(_name, _VIN, _R, _N) \
NET_REGISTER_DEV(R2R_DAC, _name) \
NETDEV_PARAMI(_name, VIN, _VIN) \
NETDEV_PARAMI(_name, R, _R) \
NETDEV_PARAMI(_name, N, _N)
#define R2R_DAC(name, p_VIN, p_R, p_N) \
NET_REGISTER_DEV(R2R_DAC, name) \
NETDEV_PARAMI(name, VIN, p_VIN) \
NETDEV_PARAMI(name, R, p_R) \
NETDEV_PARAMI(name, N, p_N)
NETLIB_NAMESPACE_DEVICES_START()

88
src/lib/netlist/devices/nld_system.h
View File

@ -18,62 +18,62 @@
// Macros
// -----------------------------------------------------------------------------
#define TTL_INPUT(_name, _v) \
NET_REGISTER_DEV(TTL_INPUT, _name) \
PARAM(_name.IN, _v)
#define TTL_INPUT(name, v) \
NET_REGISTER_DEV(TTL_INPUT, name) \
PARAM(name.IN, v)
#define LOGIC_INPUT(_name, _v, _family) \
NET_REGISTER_DEV(LOGIC_INPUT, _name) \
PARAM(_name.IN, _v) \
PARAM(_name.FAMILY, _family)
#define LOGIC_INPUT(name, v, family) \
NET_REGISTER_DEV(LOGIC_INPUT, name) \
PARAM(name.IN, v) \
PARAM(name.FAMILY, family)
#define ANALOG_INPUT(_name, _v) \
NET_REGISTER_DEV(ANALOG_INPUT, _name) \
PARAM(_name.IN, _v)
#define ANALOG_INPUT(name, v) \
NET_REGISTER_DEV(ANALOG_INPUT, name) \
PARAM(name.IN, v)
#define MAINCLOCK(_name, _freq) \
NET_REGISTER_DEV(MAINCLOCK, _name) \
PARAM(_name.FREQ, _freq)
#define MAINCLOCK(name, freq) \
NET_REGISTER_DEV(MAINCLOCK, name) \
PARAM(name.FREQ, freq)
#define CLOCK(_name, _freq) \
NET_REGISTER_DEV(CLOCK, _name) \
PARAM(_name.FREQ, _freq)
#define CLOCK(name, freq) \
NET_REGISTER_DEV(CLOCK, name) \
PARAM(name.FREQ, freq)
#define EXTCLOCK(_name, _freq, _pattern) \
NET_REGISTER_DEV(EXTCLOCK, _name) \
PARAM(_name.FREQ, _freq) \
PARAM(_name.PATTERN, _pattern)
#define EXTCLOCK(name, freq, pattern) \
NET_REGISTER_DEV(EXTCLOCK, name) \
PARAM(name.FREQ, freq) \
PARAM(name.PATTERN, pattern)
#define GNDA() \
NET_REGISTER_DEV(GNDA, GND)
#define DUMMY_INPUT(_name) \
NET_REGISTER_DEV(DUMMY_INPUT, _name)
#define DUMMY_INPUT(name) \
NET_REGISTER_DEV(DUMMY_INPUT, name)
//FIXME: Usage discouraged, use OPTIMIZE_FRONTIER instead
#define FRONTIER_DEV(_name, _IN, _G, _OUT) \
NET_REGISTER_DEV(FRONTIER_DEV, _name) \
NET_C(_IN, _name.I) \
NET_C(_G, _name.G) \
NET_C(_OUT, _name.Q)
#define FRONTIER_DEV(name, cIN, cG, cOUT) \
NET_REGISTER_DEV(FRONTIER_DEV, name) \
NET_C(cIN, name.I) \
NET_C(cG, name.G) \
NET_C(cOUT, name.Q)
#define OPTIMIZE_FRONTIER(_attach, _r_in, _r_out) \
setup.register_frontier(# _attach, _r_in, _r_out);
#define OPTIMIZE_FRONTIER(attach, r_in, r_out) \
setup.register_frontier(# attach, r_in, r_out);
#define RES_SWITCH(_name, _IN, _P1, _P2) \
NET_REGISTER_DEV(RES_SWITCH, _name) \
NET_C(_IN, _name.I) \
NET_C(_P1, _name.1) \
NET_C(_P2, _name.2)
#define RES_SWITCH(name, cIN, cP1, cP2) \
NET_REGISTER_DEV(RES_SWITCH, name) \
NET_C(cIN, name.I) \
NET_C(cP1, name.1) \
NET_C(cP2, name.2)
/* Default device to hold netlist parameters */
#define PARAMETERS(_name) \
NET_REGISTER_DEV(PARAMETERS, _name)
#define PARAMETERS(name) \
NET_REGISTER_DEV(PARAMETERS, name)
#define AFUNC(_name, _N, _F) \
NET_REGISTER_DEV(AFUNC, _name) \
PARAM(_name.N, _N) \
PARAM(_name.FUNC, _F)
#define AFUNC(name, p_N, p_F) \
NET_REGISTER_DEV(AFUNC, name) \
PARAM(name.N, p_N) \
PARAM(name.FUNC, p_F)
NETLIB_NAMESPACE_DEVICES_START()
@ -617,18 +617,18 @@ public:
class wrapper : public device_t
{
public:
wrapper(const pstring &dev_name, netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_dev_name(dev_name)
wrapper(const pstring &devname, netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_devname(devname)
{
anetlist.setup().namespace_push(name);
anetlist.setup().include(m_dev_name);
anetlist.setup().include(m_devname);
anetlist.setup().namespace_pop();
}
protected:
NETLIB_RESETI() { }
NETLIB_UPDATEI() { }
pstring m_dev_name;
pstring m_devname;
};
plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override

8
src/lib/netlist/devices/nld_truthtable.cpp
View File

@ -241,13 +241,13 @@ void truthtable_desc_t::setup(const plib::pstring_vector_t &truthtable, UINT32 d
}
#define ENTRYX(_n,_m,_h) case (_n * 1000 + _m * 10 + _h): \
{ using xtype = netlist_factory_truthtable_t<_n,_m,_h>; \
#define ENTRYX(n, m, h) case (n * 1000 + m * 10 + h): \
{ using xtype = netlist_factory_truthtable_t<n, m, h>; \
return plib::powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break
#define ENTRYY(_n,_m) ENTRYX(_n,_m,0); ENTRYX(_n,_m,1)
#define ENTRYY(n, m) ENTRYX(n, m, 0); ENTRYX(n, m, 1)
#define ENTRY(_n) ENTRYY(_n, 1); ENTRYY(_n, 2); ENTRYY(_n, 3); ENTRYY(_n, 4); ENTRYY(_n, 5); ENTRYY(_n, 6)
#define ENTRY(n) ENTRYY(n, 1); ENTRYY(n, 2); ENTRYY(n, 3); ENTRYY(n, 4); ENTRYY(n, 5); ENTRYY(n, 6)
plib::powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no,
const unsigned has_state,

38
src/lib/netlist/devices/nld_truthtable.h
View File

@ -13,31 +13,31 @@
#include "nl_base.h"
#include "nl_factory.h"
#define NETLIB_TRUTHTABLE(_name, _nIN, _nOUT, _state) \
class NETLIB_NAME(_name) : public nld_truthtable_t<_nIN, _nOUT, _state> \
{ \
public: \
template <class C> \
NETLIB_NAME(_name)(C &owner, const pstring &name) \
: nld_truthtable_t<_nIN, _nOUT, _state>(owner, name, nullptr, &m_ttbl, m_desc) { } \
private: \
static truthtable_t m_ttbl; \
static const char *m_desc[]; \
#define NETLIB_TRUTHTABLE(cname, nIN, nOUT, state) \
class NETLIB_NAME(cname) : public nld_truthtable_t<nIN, nOUT, state> \
{ \
public: \
template <class C> \
NETLIB_NAME(cname)(C &owner, const pstring &name) \
: nld_truthtable_t<nIN, nOUT, state>(owner, name, nullptr, &m_ttbl, m_desc) { } \
private: \
static truthtable_t m_ttbl; \
static const char *m_desc[]; \
}
#define TRUTHTABLE_START(_name, _in, _out, _has_state, _def_params) \
#define TRUTHTABLE_START(cname, in, out, has_state, def_params) \
{ \
auto ttd = netlist::devices::nl_tt_factory_create(_in, _out, _has_state, \
# _name, # _name, "+" _def_params);
auto ttd = netlist::devices::nl_tt_factory_create(in, out, has_state, \
# cname, # cname, "+" def_params);
#define TT_HEAD(_x) \
ttd->m_desc.push_back(_x);
#define TT_HEAD(x) \
ttd->m_desc.push_back(x);
#define TT_LINE(_x) \
ttd->m_desc.push_back(_x);
#define TT_LINE(x) \
ttd->m_desc.push_back(x);
#define TT_FAMILY(_x) \
ttd->m_family = setup.family_from_model(_x);
#define TT_FAMILY(x) \
ttd->m_family = setup.family_from_model(x);
#define TRUTHTABLE_END() \
setup.factory().register_device(std::move(ttd)); \

20
src/lib/netlist/macro/nlm_cd4xxx.h
View File

@ -22,24 +22,24 @@
* Netlist Macros
* ---------------------------------------------------------------------------*/
#define CD4001_NOR(_name) \
NET_REGISTER_DEV(CD4001_NOR, _name)
#define CD4001_NOR(name) \
NET_REGISTER_DEV(CD4001_NOR, name)
#define CD4001_DIP(_name) \
NET_REGISTER_DEV(CD4001_DIP, _name)
#define CD4001_DIP(name) \
NET_REGISTER_DEV(CD4001_DIP, name)
/* ----------------------------------------------------------------------------
* DIP only macros
* ---------------------------------------------------------------------------*/
#define CD4020_DIP(_name) \
NET_REGISTER_DEV(CD4020_DIP, _name)
#define CD4020_DIP(name) \
NET_REGISTER_DEV(CD4020_DIP, name)
#define CD4066_DIP(_name) \
NET_REGISTER_DEV(CD4066_DIP, _name)
#define CD4066_DIP(name) \
NET_REGISTER_DEV(CD4066_DIP, name)
#define CD4016_DIP(_name) \
NET_REGISTER_DEV(CD4016_DIP, _name)
#define CD4016_DIP(name) \
NET_REGISTER_DEV(CD4016_DIP, name)
/* ----------------------------------------------------------------------------
* External declarations

12
src/lib/netlist/macro/nlm_opamp.h
View File

@ -11,14 +11,14 @@
* Netlist Macros
* ---------------------------------------------------------------------------*/
#define MB3614_DIP(_name) \
NET_REGISTER_DEV(MB3614_DIP, _name)
#define MB3614_DIP(name) \
NET_REGISTER_DEV(MB3614_DIP, name)
#define LM324_DIP(_name) \
NET_REGISTER_DEV(LM324_DIP, _name)
#define LM324_DIP(name) \
NET_REGISTER_DEV(LM324_DIP, name)
#define LM358_DIP(_name) \
NET_REGISTER_DEV(LM358_DIP, _name)
#define LM358_DIP(name) \
NET_REGISTER_DEV(LM358_DIP, name)
/* ----------------------------------------------------------------------------
* External declarations

8
src/lib/netlist/macro/nlm_other.h
View File

@ -11,11 +11,11 @@
* Netlist Macros
* ---------------------------------------------------------------------------*/
#define MC14584B_GATE(_name) \
NET_REGISTER_DEV(MC14584B_GATE, _name)
#define MC14584B_GATE(name) \
NET_REGISTER_DEV(MC14584B_GATE, name)
#define MC14584B_DIP(_name) \
NET_REGISTER_DEV(MC14584B_DIP, _name)
#define MC14584B_DIP(name) \
NET_REGISTER_DEV(MC14584B_DIP, name)
/* ----------------------------------------------------------------------------

18
src/lib/netlist/macro/nlm_ttl74xx.cpp
View File

@ -9,7 +9,7 @@
/*
* DM7400: Quad 2-Input NAND Gates
*
* __
* _
* Y = AB
* +---+---++---+
* | A | B || Y |
@ -85,7 +85,7 @@ NETLIST_END()
/*
* DM7404: Hex Inverting Gates
* _
*
* Y = A
* +---++---+
* | A || Y |
@ -162,7 +162,7 @@ NETLIST_END()
/*
* DM7410: Triple 3-Input NAND Gates
* ___
* __
* Y = ABC
* +---+---+---++---+
* | A | B | C || Y |
@ -266,7 +266,7 @@ NETLIST_END()
/*
* DM7420: Dual 4-Input NAND Gates
*
* ____
* ___
* Y = ABCD
* +---+---+---+---++---+
* | A | B | C | D || Y |
@ -304,7 +304,7 @@ NETLIST_END()
/*
* DM7425: Dual 4-Input NOR Gates
*
* _______
* ______
* Y = A+B+C+D
* +---+---+---+---+---++---+
* | A | B | C | D | X || Y |
@ -346,7 +346,7 @@ NETLIST_END()
/*
* DM7427: Triple 3-Input NOR Gates
*
* _____
* ____
* Y = A+B+C
* +---+---+---++---+
* | A | B | C || Y |
@ -384,7 +384,7 @@ NETLIST_END()
/*
* DM7430: 8-Input NAND Gate
*
* ________
* _______
* Y = ABCDEFGH
* +---+---+---+---+---+---+---+---++---+
* | A | B | C | D | E | F | G | H || Y |
@ -424,7 +424,7 @@ NETLIST_END()
/*
* DM7432: Quad 2-Input OR Gates
*
* ___
* __
* Y = A+B
* +---+---++---+
* | A | B || Y |
@ -464,7 +464,7 @@ NETLIST_END()
/*
* DM7437: Quad 2-Input NAND Gates
*
* __
* _
* Y = AB
* +---+---++---+
* | A | B || Y |

240
src/lib/netlist/macro/nlm_ttl74xx.h
View File

@ -11,179 +11,179 @@
* Netlist Macros
* ---------------------------------------------------------------------------*/
#define TTL_7400_GATE(_name) \
NET_REGISTER_DEV(TTL_7400_GATE, _name)
#define TTL_7400_GATE(name) \
NET_REGISTER_DEV(TTL_7400_GATE, name)
#define TTL_7400_NAND(_name, _A, _B) \
NET_REGISTER_DEV(TTL_7400_NAND, _name) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B)
#define TTL_7400_NAND(name, cA, cB) \
NET_REGISTER_DEV(TTL_7400_NAND, name) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB)
#define TTL_7400_DIP(_name) \
NET_REGISTER_DEV(TTL_7400_DIP, _name)
#define TTL_7400_DIP(name) \
NET_REGISTER_DEV(TTL_7400_DIP, name)
#define TTL_7402_GATE(_name) \
NET_REGISTER_DEV(TTL_7402_GATE, _name)
#define TTL_7402_GATE(name) \
NET_REGISTER_DEV(TTL_7402_GATE, name)
#define TTL_7402_NOR(_name, _I1, _I2) \
NET_REGISTER_DEV(TTL_7402_NOR, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2)
#define TTL_7402_NOR(name, cI1, cI2) \
NET_REGISTER_DEV(TTL_7402_NOR, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2)
#define TTL_7402_DIP(_name) \
NET_REGISTER_DEV(TTL_7402_DIP, _name)
#define TTL_7402_DIP(name) \
NET_REGISTER_DEV(TTL_7402_DIP, name)
#define TTL_7404_GATE(_name) \
NET_REGISTER_DEV(TTL_7404_GATE, _name)
#define TTL_7404_GATE(name) \
NET_REGISTER_DEV(TTL_7404_GATE, name)
#define TTL_7404_INVERT(_name, _A) \
NET_REGISTER_DEV(TTL_7404_INVERT, _name) \
NET_CONNECT(_name, A, _A)
#define TTL_7404_INVERT(name, cA) \
NET_REGISTER_DEV(TTL_7404_INVERT, name) \
NET_CONNECT(name, A, cA)
#define TTL_7404_DIP(_name) \
NET_REGISTER_DEV(TTL_7404_DIP, _name)
#define TTL_7404_DIP(name) \
NET_REGISTER_DEV(TTL_7404_DIP, name)
#define TTL_7408_GATE(_name) \
NET_REGISTER_DEV(TTL_7408_GATE, _name)
#define TTL_7408_GATE(name) \
NET_REGISTER_DEV(TTL_7408_GATE, name)
#define TTL_7408_AND(_name, _A, _B) \
NET_REGISTER_DEV(TTL_7408_AND, _name) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B)
#define TTL_7408_AND(name, cA, cB) \
NET_REGISTER_DEV(TTL_7408_AND, name) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB)
#define TTL_7408_DIP(_name) \
NET_REGISTER_DEV(TTL_7408_DIP, _name)
#define TTL_7408_DIP(name) \
NET_REGISTER_DEV(TTL_7408_DIP, name)
#define TTL_7410_GATE(_name) \
NET_REGISTER_DEV(TTL_7410_GATE, _name)
#define TTL_7410_GATE(name) \
NET_REGISTER_DEV(TTL_7410_GATE, name)
#define TTL_7410_NAND(_name, _I1, _I2, _I3) \
NET_REGISTER_DEV(TTL_7410_NAND, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3)
#define TTL_7410_NAND(name, cI1, cI2, cI3) \
NET_REGISTER_DEV(TTL_7410_NAND, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3)
#define TTL_7410_DIP(_name) \
NET_REGISTER_DEV(TTL_7410_DIP, _name)
#define TTL_7410_DIP(name) \
NET_REGISTER_DEV(TTL_7410_DIP, name)
#define TTL_7411_GATE(_name) \
NET_REGISTER_DEV(TTL_7411_GATE, _name)
#define TTL_7411_GATE(name) \
NET_REGISTER_DEV(TTL_7411_GATE, name)
#define TTL_7411_AND(_name, _I1, _I2, _I3) \
NET_REGISTER_DEV(TTL_7411_AND, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3)
#define TTL_7411_AND(name, cI1, cI2, cI3) \
NET_REGISTER_DEV(TTL_7411_AND, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3)
#define TTL_7411_DIP(_name) \
NET_REGISTER_DEV(TTL_7411_DIP, _name)
#define TTL_7411_DIP(name) \
NET_REGISTER_DEV(TTL_7411_DIP, name)
#define TTL_7416_GATE(_name) \
NET_REGISTER_DEV(TTL_7416_GATE, _name)
#define TTL_7416_GATE(name) \
NET_REGISTER_DEV(TTL_7416_GATE, name)
#define TTL_7416_DIP(_name) \
NET_REGISTER_DEV(TTL7416_DIP, _name)
#define TTL_7416_DIP(name) \
NET_REGISTER_DEV(TTL7416_DIP, name)
#define TTL_7420_GATE(_name) \
NET_REGISTER_DEV(TTL_7420_GATE, _name)
#define TTL_7420_GATE(name) \
NET_REGISTER_DEV(TTL_7420_GATE, name)
#define TTL_7420_NAND(_name, _I1, _I2, _I3, _I4) \
NET_REGISTER_DEV(TTL_7420_NAND, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3) \
NET_CONNECT(_name, D, _I4)
#define TTL_7420_NAND(name, cI1, cI2, cI3, cI4) \
NET_REGISTER_DEV(TTL_7420_NAND, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3) \
NET_CONNECT(name, D, cI4)
#define TTL_7420_DIP(_name) \
NET_REGISTER_DEV(TTL_7420_DIP, _name)
#define TTL_7420_DIP(name) \
NET_REGISTER_DEV(TTL_7420_DIP, name)
#define TTL_7425_GATE(_name) \
NET_REGISTER_DEV(TTL_7425_GATE, _name)
#define TTL_7425_GATE(name) \
NET_REGISTER_DEV(TTL_7425_GATE, name)
#define TTL_7425_NOR(_name, _I1, _I2, _I3, _I4) \
NET_REGISTER_DEV(TTL_7425_NOR, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3) \
NET_CONNECT(_name, D, _I4)
#define TTL_7425_NOR(name, cI1, cI2, cI3, cI4) \
NET_REGISTER_DEV(TTL_7425_NOR, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3) \
NET_CONNECT(name, D, cI4)
#define TTL_7425_DIP(_name) \
NET_REGISTER_DEV(TTL_7425_DIP, _name)
#define TTL_7425_DIP(name) \
NET_REGISTER_DEV(TTL_7425_DIP, name)
#define TTL_7427_GATE(_name) \
NET_REGISTER_DEV(TTL_7427_GATE, _name)
#define TTL_7427_GATE(name) \
NET_REGISTER_DEV(TTL_7427_GATE, name)
#define TTL_7427_NOR(_name, _I1, _I2, _I3) \
NET_REGISTER_DEV(TTL_7427_NOR, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3)
#define TTL_7427_NOR(name, cI1, cI2, cI3) \
NET_REGISTER_DEV(TTL_7427_NOR, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3)
#define TTL_7427_DIP(_name) \
NET_REGISTER_DEV(TTL_7427_DIP, _name)
#define TTL_7427_DIP(name) \
NET_REGISTER_DEV(TTL_7427_DIP, name)
#define TTL_7430_GATE(_name) \
NET_REGISTER_DEV(TTL_7430_GATE, _name)
#define TTL_7430_GATE(name) \
NET_REGISTER_DEV(TTL_7430_GATE, name)
#define TTL_7430_NAND(_name, _I1, _I2, _I3, _I4, _I5, _I6, _I7, _I8) \
NET_REGISTER_DEV(TTL_7430_NAND, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3) \
NET_CONNECT(_name, D, _I4) \
NET_CONNECT(_name, E, _I5) \
NET_CONNECT(_name, F, _I6) \
NET_CONNECT(_name, G, _I7) \
NET_CONNECT(_name, H, _I8)
#define TTL_7430_NAND(name, cI1, cI2, cI3, cI4, cI5, cI6, cI7, cI8) \
NET_REGISTER_DEV(TTL_7430_NAND, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2) \
NET_CONNECT(name, C, cI3) \
NET_CONNECT(name, D, cI4) \
NET_CONNECT(name, E, cI5) \
NET_CONNECT(name, F, cI6) \
NET_CONNECT(name, G, cI7) \
NET_CONNECT(name, H, cI8)
#define TTL_7430_DIP(_name) \
NET_REGISTER_DEV(TTL_7430_DIP, _name)
#define TTL_7430_DIP(name) \
NET_REGISTER_DEV(TTL_7430_DIP, name)
#define TTL_7432_GATE(_name) \
NET_REGISTER_DEV(TTL_7432_OR, _name)
#define TTL_7432_GATE(name) \
NET_REGISTER_DEV(TTL_7432_OR, name)
#define TTL_7432_OR(_name, _I1, _I2) \
NET_REGISTER_DEV(TTL_7432_OR, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2)
#define TTL_7432_OR(name, cI1, cI2) \
NET_REGISTER_DEV(TTL_7432_OR, name) \
NET_CONNECT(name, A, cI1) \
NET_CONNECT(name, B, cI2)
#define TTL_7432_DIP(_name) \
NET_REGISTER_DEV(TTL_7432_DIP, _name)
#define TTL_7432_DIP(name) \
NET_REGISTER_DEV(TTL_7432_DIP, name)
#define TTL_7437_GATE(_name) \
NET_REGISTER_DEV(TTL_7437_GATE, _name)
#define TTL_7437_GATE(name) \
NET_REGISTER_DEV(TTL_7437_GATE, name)
#define TTL_7437_NAND(_name, _A, _B) \
NET_REGISTER_DEV(TTL_7437_NAND, _name) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B)
#define TTL_7437_NAND(name, cA, cB) \
NET_REGISTER_DEV(TTL_7437_NAND, name) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB)
#define TTL_7437_DIP(_name) \
NET_REGISTER_DEV(TTL_7437_DIP, _name)
#define TTL_7437_DIP(name) \
NET_REGISTER_DEV(TTL_7437_DIP, name)
#define TTL_7486_GATE(_name) \
NET_REGISTER_DEV(TTL_7486_GATE, _name)
#define TTL_7486_GATE(name) \
NET_REGISTER_DEV(TTL_7486_GATE, name)
#define TTL_7486_XOR(_name, _A, _B) \
NET_REGISTER_DEV(TTL_7486_XOR, _name) \
NET_CONNECT(_name, A, _A) \
NET_CONNECT(_name, B, _B)
#define TTL_7486_XOR(name, cA, cB) \
NET_REGISTER_DEV(TTL_7486_XOR, name) \
NET_CONNECT(name, A, cA) \
NET_CONNECT(name, B, cB)
#define TTL_7486_DIP(_name) \
NET_REGISTER_DEV(TTL_7486_DIP, _name)
#define TTL_7486_DIP(name) \
NET_REGISTER_DEV(TTL_7486_DIP, name)
/* ----------------------------------------------------------------------------
* External declarations

60
src/lib/netlist/nl_base.h
View File

@ -183,29 +183,29 @@ using netlist_sig_t = std::uint32_t;
#define NETLIB_NAMESPACE_DEVICES_START() namespace netlist { namespace devices {
#define NETLIB_NAMESPACE_DEVICES_END() }}
#define NETLIB_NAME(_chip) nld_ ## _chip
#define NETLIB_NAME(chip) nld_ ## chip
#define NETLIB_OBJECT_DERIVED(_name, _pclass) \
class NETLIB_NAME(_name) : public NETLIB_NAME(_pclass)
#define NETLIB_OBJECT_DERIVED(name, pclass) \
class NETLIB_NAME(name) : public NETLIB_NAME(pclass)
#define NETLIB_OBJECT(_name) \
class NETLIB_NAME(_name) : public device_t
#define NETLIB_OBJECT(name) \
class NETLIB_NAME(name) : public device_t
#define NETLIB_CONSTRUCTOR_DERIVED(_name, _pclass) \
#define NETLIB_CONSTRUCTOR_DERIVED(cname, pclass) \
private: family_setter_t m_famsetter; \
public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name) \
: NETLIB_NAME(_pclass)(owner, name)
public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name) \
: NETLIB_NAME(pclass)(owner, name)
#define NETLIB_CONSTRUCTOR(_name) \
#define NETLIB_CONSTRUCTOR(cname) \
private: family_setter_t m_famsetter; \
public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name) \
public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name) \
: device_t(owner, name)
#define NETLIB_DESTRUCTOR(_name) public: ATTR_HOT virtual ~NETLIB_NAME(_name)()
#define NETLIB_DESTRUCTOR(name) public: ATTR_HOT virtual ~NETLIB_NAME(name)()
#define NETLIB_CONSTRUCTOR_EX(_name, ...) \
#define NETLIB_CONSTRUCTOR_EX(cname, ...) \
private: family_setter_t m_famsetter; \
public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name, __VA_ARGS__) \
public: template <class CLASS> ATTR_COLD NETLIB_NAME(cname)(CLASS &owner, const pstring name, __VA_ARGS__) \
: device_t(owner, name)
#define NETLIB_DYNAMIC() \
@ -218,26 +218,26 @@ class NETLIB_NAME(_name) : public device_t
#define NETLIB_UPDATE_AFTER_PARAM_CHANGE() \
public: ATTR_HOT virtual bool needs_update_after_param_change() const override { return true; }
#define NETLIB_FAMILY(_family) , m_famsetter(*this, _family)
#define NETLIB_FAMILY(family) , m_famsetter(*this, family)
#define NETLIB_UPDATE_TERMINALSI() public: ATTR_HOT virtual void update_terminals() override
#define NETLIB_UPDATEI() protected: ATTR_HOT virtual void update() NOEXCEPT override
#define NETLIB_UPDATE_PARAMI() public: ATTR_HOT virtual void update_param() override
#define NETLIB_RESETI() protected: ATTR_HOT virtual void reset() override
#define NETLIB_SUB(_chip) nld_ ## _chip
#define NETLIB_SUBXX(_chip) std::unique_ptr< nld_ ## _chip >
#define NETLIB_SUB(chip) nld_ ## chip
#define NETLIB_SUBXX(chip) std::unique_ptr< nld_ ## chip >
#define NETLIB_UPDATE(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update(void) NOEXCEPT
#define NETLIB_UPDATE(chip) ATTR_HOT void NETLIB_NAME(chip) :: update(void) NOEXCEPT
#define NETLIB_RESET(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: reset(void)
#define NETLIB_RESET(chip) ATTR_COLD void NETLIB_NAME(chip) :: reset(void)
#define NETLIB_STOP(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: stop(void)
#define NETLIB_STOP(chip) ATTR_COLD void NETLIB_NAME(chip) :: stop(void)
#define NETLIB_UPDATE_PARAM(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update_param(void)
#define NETLIB_FUNC_VOID(_chip, _name, _params) ATTR_HOT void NETLIB_NAME(_chip) :: _name _params
#define NETLIB_UPDATE_PARAM(chip) ATTR_HOT void NETLIB_NAME(chip) :: update_param(void)
#define NETLIB_FUNC_VOID(chip, name, params) ATTR_HOT void NETLIB_NAME(chip) :: name params
#define NETLIB_UPDATE_TERMINALS(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update_terminals(void)
#define NETLIB_UPDATE_TERMINALS(chip) ATTR_HOT void NETLIB_NAME(chip) :: update_terminals(void)
//============================================================
@ -1226,26 +1226,26 @@ namespace netlist
ATTR_COLD net_t *find_net(const pstring &name);
template<class _device_class>
ATTR_COLD plib::pvector_t<_device_class *> get_device_list()
template<class device_class>
ATTR_COLD plib::pvector_t<device_class *> get_device_list()
{
plib::pvector_t<_device_class *> tmp;
plib::pvector_t<device_class *> tmp;
for (auto &d : m_devices)
{
_device_class *dev = dynamic_cast<_device_class *>(d.get());
device_class *dev = dynamic_cast<device_class *>(d.get());
if (dev != nullptr)
tmp.push_back(dev);
}
return tmp;
}
template<class _device_class>
ATTR_COLD _device_class *get_single_device(const char *classname)
template<class device_class>
ATTR_COLD device_class *get_single_device(const char *classname)
{
_device_class *ret = nullptr;
device_class *ret = nullptr;
for (auto &d : m_devices)
{
_device_class *dev = dynamic_cast<_device_class *>(d.get());
device_class *dev = dynamic_cast<device_class *>(d.get());
if (dev != nullptr)
{
if (ret != nullptr)

4
src/lib/netlist/nl_config.h
View File

@ -118,8 +118,8 @@
// General Macros
//============================================================
#if defined(_OPENMP)
#define HAS_OPENMP ( _OPENMP >= 200805 )
#if defined(OPENMP)
#define HAS_OPENMP ( OPENMP >= 200805 )
#else
#define HAS_OPENMP (0)
#endif

154
src/lib/netlist/nl_dice_compat.h
View File

@ -39,24 +39,24 @@ sed -e 's/#define \(.*\)"\(.*\)"[ \t]*,[ \t]*\(.*\)/NET_ALIAS(\1,\2.\3)/' src/ma
* a temporary support and not be used in commits.
*/
#define NETLIB_NAME_STR_S(_s) # _s
#define NETLIB_NAME_STR(_chip) NETLIB_NAME_STR_S(nld_ ## _chip)
#define NETLIB_NAME_STR_S(s) # s
#define NETLIB_NAME_STR(chip) NETLIB_NAME_STR_S(nld_ ## chip)
#ifndef NL_CONVERT_CPP
#ifndef NETLIST_DEVELOPMENT
#define NETLIST_DEVELOPMENT 0
#endif
#if (NETLIST_DEVELOPMENT)
#define CHIP(_n, _t) setup.register_dev( palloc(netlist::devices::nld_ ## _t ## _dip), _n);
#define CHIP(n, t) setup.register_dev( palloc(netlist::devices::nld_ ## t ## dip), n);
#else
#define CHIP(_n, _t) setup.register_dev(NETLIB_NAME_STR_S(TTL_ ## _t ## _DIP), _n);
//#define CHIP(_n, _t) TTL_ ## _t ## _DIP(_n)
#define CHIP(n, t) setup.register_dev(NETLIB_NAME_STR_S(TTL_ ## t ## _DIP), n);
//#define CHIP(n, t) TTL_ ## t ## _DIP(n)
#endif
#define CONNECTION( ... ) CONNECTIONY( CONNECTIONX( __VA_ARGS__ ) )
#define CONNECTIONY(_a) _a
#define CONNECTIONX(_a, _b, _c, _d) setup.register_link(_a "." # _b, _c "." # _d);
#define NET_CSTR(_a, _b) setup.register_link( _a, _b);
#define CONNECTIONY(a) a
#define CONNECTIONX(a, b, c, d) setup.register_link(a "." # b, c "." # d);
#define NET_CSTR(a, b) setup.register_link( a, b);
#define OHM(x) (x)
#define K_OHM(x) ((x) * 1000.0)
@ -105,7 +105,7 @@ public:
};
#else
#define CHIP(_n, _t) TTL_ ## _t ## _DIP(_n)
#define CHIP(n, t) TTL_ ## t ## DIP(n)
#define OHM(x) x
#define K_OHM(x) RES_K(X)
@ -120,75 +120,75 @@ public:
#define CIRCUIT_LAYOUT(x) NETLIST_START(x)
#define CIRCUIT_LAYOUT_END NETLIST_END()
#define CHIP_555_Mono(_name, _pdesc) \
NE555_DIP(_name) \
NET_C(_name.6, _name.7) \
RES(_name ## _R, (_pdesc)->r) \
CAP(_name ## _C, (_pdesc)->c) \
NET_C(_name.6, _name ## _R.1) \
NET_C(_name.6, _name ## _C.1) \
NET_C(_name ## _R.2, V5) \
NET_CSTR(# _name "_C.2", "GND") \
NET_C(_name.8, V5) \
NET_CSTR(# _name ".1", "GND")
#define CHIP_555_Mono(name, pdesc) \
NE555_DIP(name) \
NET_C(name.6, name.7) \
RES(name ## _R, (pdesc)->r) \
CAP(name ## _C, (pdesc)->c) \
NET_C(name.6, name ## _R.1) \
NET_C(name.6, name ## _C.1) \
NET_C(name ## _R.2, V5) \
NET_CSTR(# name "_C.2", "GND") \
NET_C(name.8, V5) \
NET_CSTR(# name ".1", "GND")
#define CHIP_555_Astable(_name, _pdesc) \
NE555_DIP(_name) \
RES(_name ## _R1, (_pdesc)->r1) \
RES(_name ## _R2, (_pdesc)->r2) \
CAP(_name ## _C, (_pdesc)->c) \
NET_C(_name.7, _name ## _R1.1) \
NET_C(_name.7, _name ## _R2.1) \
NET_C(_name.6, _name ## _R2.2) \
NET_C(_name.6, _name ## _C.1) \
NET_C(_name.2, _name ## _C.1) \
NET_C(_name ## _R1.2, V5) \
NET_CSTR(# _name "_C.2", "GND") \
NET_C(_name.8, V5) \
NET_CSTR(# _name ".1", "GND")
#define CHIP_555_Astable(name, pdesc) \
NE555_DIP(name) \
RES(name ## _R1, (pdesc)->r1) \
RES(name ## _R2, (pdesc)->r2) \
CAP(name ## _C, (pdesc)->c) \
NET_C(name.7, name ## _R1.1) \
NET_C(name.7, name ## _R2.1) \
NET_C(name.6, name ## _R2.2) \
NET_C(name.6, name ## _C.1) \
NET_C(name.2, name ## _C.1) \
NET_C(name ## _R1.2, V5) \
NET_CSTR(# name "_C.2", "GND") \
NET_C(name.8, V5) \
NET_CSTR(# name ".1", "GND")
#define CHIP_9602_Mono(_name, _pdesc) \
CHIP(# _name, 9602) \
NET_C(VCC, _name.16) \
NET_C(GND, _name.8) \
RES(_name ## _R1, (_pdesc)->r1) \
CAP(_name ## _C1, (_pdesc)->c1) \
RES(_name ## _R2, (_pdesc)->r2) \
NET_C(_name.1, _name ## _C1.1) \
NET_C(_name.2, _name ## _C1.2) \
NET_C(_name.2, _name ## _R1.2) \
NET_C(VCC, _name ## _R1.1) \
if (((_pdesc)->c2)>1e-15) { \
CAP(_name ## _C2, (_pdesc)->c2) \
NET_C(_name.15, _name ## _C2.1) \
NET_C(_name.14, _name ## _C2.2) }\
NET_C(_name.14, _name ## _R2.2) \
NET_C(VCC, _name ## _R2.1)
#define CHIP_SERIES_RC(_name, _pdesc) \
RES(_name ## _R, (_pdesc)->r) \
CAP(_name ## _C, (_pdesc)->c) \
NET_C(_name ## _R.1, _name ## _C.2) \
ALIAS(_name.3, _name ## _R.1) \
ALIAS(_name.2, _name ## _R.2) \
ALIAS(_name.1, _name ## _C.1)
#define CHIP_9602_Mono(name, pdesc) \
CHIP(# name, 9602) \
NET_C(VCC, name.16) \
NET_C(GND, name.8) \
RES(name ## _R1, (pdesc)->r1) \
CAP(name ## _C1, (pdesc)->c1) \
RES(name ## _R2, (pdesc)->r2) \
NET_C(name.1, name ## _C1.1) \
NET_C(name.2, name ## _C1.2) \
NET_C(name.2, name ## _R1.2) \
NET_C(VCC, name ## _R1.1) \
if (((pdesc)->c2)>1e-15) { \
CAP(name ## _C2, (pdesc)->c2) \
NET_C(name.15, name ## _C2.1) \
NET_C(name.14, name ## _C2.2) }\
NET_C(name.14, name ## _R2.2) \
NET_C(VCC, name ## _R2.1)
#define CHIP_SERIES_RC(name, pdesc) \
RES(name ## _R, (pdesc)->r) \
CAP(name ## _C, (pdesc)->c) \
NET_C(name ## _R.1, name ## _C.2) \
ALIAS(name.3, name ## _R.1) \
ALIAS(name.2, name ## _R.2) \
ALIAS(name.1, name ## _C.1)
#define CHIP_INPUT_ACTIVE_LOW(_name) \
SWITCH2(_name ## _SW) \
NET_C(_name ## _SW.1, V5) \
NET_CSTR(# _name "_SW.2", "GND") \
ALIAS(_name.1, _name ## _SW.Q)
#define CHIP_INPUT_ACTIVE_LOW(name) \
SWITCH2(name ## _SW) \
NET_C(name ## _SW.1, V5) \
NET_CSTR(# name "_SW.2", "GND") \
ALIAS(name.1, name ## _SW.Q)
#define CHIP_INPUT_ACTIVE_HIGH(_name) \
SWITCH2(_name ## _SW) \
NET_C(_name ## _SW.2, V5) \
NET_CSTR(# _name "_SW.1", "GND") \
ALIAS(_name.1, _name ## _SW.Q)
#define CHIP_INPUT_ACTIVE_HIGH(name) \
SWITCH2(name ## _SW) \
NET_C(name ## _SW.2, V5) \
NET_CSTR(# name "_SW.1", "GND") \
ALIAS(name.1, name ## _SW.Q)
#define CHIP_LATCH(_name) \
NETDEV_RSFF(_name) \
ALIAS(_name.1, _name.R) \
ALIAS(_name.2, _name.S) \
ALIAS(_name.3, _name.QQ)
#define CHIP_LATCH(name) \
NETDEV_RSFF(name) \
ALIAS(name.1, name.R) \
ALIAS(name.2, name.S) \
ALIAS(name.3, name.QQ)
/* FIXME: Alternative implementation using capacitor.
* This is a transitional implementation
@ -216,9 +216,9 @@ inline int CAPACITOR_tc_lh(const double c, const double r)
return ret;
}
#define CHIP_CAPACITOR(_name, _pdesc) \
NETDEV_DELAY(_name) \
NETDEV_PARAMI(_name, L_TO_H, CAPACITOR_tc_lh((_pdesc)->c, (_pdesc)->r)) \
NETDEV_PARAMI(_name, H_TO_L, CAPACITOR_tc_hl((_pdesc)->c, (_pdesc)->r))
#define CHIP_CAPACITOR(name, pdesc) \
NETDEV_DELAY(name) \
NETDEV_PARAMI(name, L_TO_H, CAPACITOR_tc_lh((pdesc)->c, (pdesc)->r)) \
NETDEV_PARAMI(name, H_TO_L, CAPACITOR_tc_hl((pdesc)->c, (pdesc)->r))
#endif /* NL_DICE_COMPAT_H_ */

12
src/lib/netlist/nl_factory.h
View File

@ -46,7 +46,7 @@ namespace netlist
pstring m_def_param; /* default parameter */
};
template <class _device_class>
template <class device_class>
class factory_t : public base_factory_t
{
P_PREVENT_COPYING(factory_t)
@ -57,7 +57,7 @@ namespace netlist
plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override
{
return plib::powned_ptr<device_t>::Create<_device_class>(anetlist, name);
return plib::powned_ptr<device_t>::Create<device_class>(anetlist, name);
}
};
@ -68,11 +68,11 @@ namespace netlist
factory_list_t(setup_t &m_setup);
~factory_list_t();
template<class _device_class>
template<class device_class>
void register_device(const pstring &name, const pstring &classname,
const pstring &def_param)
{
register_device(plib::powned_ptr<base_factory_t>::Create<factory_t<_device_class>>(name, classname, def_param));
register_device(plib::powned_ptr<base_factory_t>::Create<factory_t<device_class>>(name, classname, def_param));
}
void register_device(plib::powned_ptr<base_factory_t> factory)
@ -88,10 +88,10 @@ namespace netlist
plib::powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name);
base_factory_t * factory_by_name(const pstring &devname);
template <class _class>
template <class C>
bool is_class(base_factory_t *f)
{
return dynamic_cast<factory_t<_class> *>(f) != nullptr;
return dynamic_cast<factory_t<C> *>(f) != nullptr;
}
private:

20
src/lib/netlist/nl_lists.h
View File

@ -22,7 +22,7 @@
namespace netlist
{
template <class _Element, class _Time>
template <class Element, class Time>
class timed_queue
{
P_PREVENT_COPYING(timed_queue)
@ -39,10 +39,10 @@ namespace netlist
ATTR_HOT entry_t(const entry_t &right) NOEXCEPT
: m_exec_time(right.m_exec_time), m_object(right.m_object) {}
#endif
ATTR_HOT entry_t(const _Time &atime, const _Element &elem) NOEXCEPT
ATTR_HOT entry_t(const Time &atime, const Element &elem) NOEXCEPT
: m_exec_time(atime), m_object(elem) {}
ATTR_HOT const _Time &exec_time() const { return m_exec_time; }
ATTR_HOT const _Element &object() const { return m_object; }
ATTR_HOT const Time &exec_time() const { return m_exec_time; }
ATTR_HOT const Element &object() const { return m_object; }
#if 0
ATTR_HOT entry_t &operator=(const entry_t &right) NOEXCEPT {
m_exec_time = right.m_exec_time;
@ -51,8 +51,8 @@ namespace netlist
}
#endif
private:
_Time m_exec_time;
_Element m_object;
Time m_exec_time;
Element m_object;
};
timed_queue(unsigned list_size)
@ -75,7 +75,7 @@ namespace netlist
while (m_lock.exchange(1)) { }
#endif
#if 1
const _Time t = e.exec_time();
const Time t = e.exec_time();
entry_t * i = m_end++;
for (; t > (i - 1)->exec_time(); i--)
{
@ -98,7 +98,7 @@ namespace netlist
#if HAS_OPENMP && USE_OPENMP
m_lock = 0;
#endif
//nl_assert(m_end - m_list < _Size);
//nl_assert(m_end - m_list < Size);
}
ATTR_HOT const entry_t & pop() NOEXCEPT
@ -111,7 +111,7 @@ namespace netlist
return *(m_end-1);
}
ATTR_HOT void remove(const _Element &elem) NOEXCEPT
ATTR_HOT void remove(const Element &elem) NOEXCEPT
{
/* Lock */
#if HAS_OPENMP && USE_OPENMP
@ -145,7 +145,7 @@ namespace netlist
* the insert algo above will run into this element and doesn't
* need a comparison with queue start.
*/
m_list[0] = entry_t(_Time::from_raw(~0), _Element(0));
m_list[0] = entry_t(Time::from_raw(~0), Element(0));
m_end++;
}

2
src/lib/netlist/nl_setup.cpp
View File

@ -944,7 +944,7 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map)
if (m_models.contains(xmodel))
model_parse(xmodel, map);
else
log().fatal("Model doesn't exist {1}\n", xmodel);
log().fatal("Model doesn't exist: <{1}>\n", model_in);
}
pstring remainder=model.substr(pos+1).trim();

64
src/lib/netlist/nl_setup.h
View File

@ -16,56 +16,56 @@
// MACROS / inline netlist definitions
//============================================================
#define NET_STR(_x) # _x
#define NET_STR(x) # x
#define NET_MODEL(_model) \
setup.register_model(_model);
#define NET_MODEL(model) \
setup.register_model(model);
#define ALIAS(_alias, _name) \
setup.register_alias(# _alias, # _name);
#define ALIAS(alias, name) \
setup.register_alias(# alias, # name);
#define DIPPINS(_pin1, ...) \
setup.register_dippins_arr( #_pin1 ", " # __VA_ARGS__);
#define DIPPINS(pin1, ...) \
setup.register_dippins_arr( # pin1 ", " # __VA_ARGS__);
/* to be used to reference new library truthtable devices */
#define NET_REGISTER_DEV(_type, _name) \
setup.register_dev(# _type, # _name);
#define NET_REGISTER_DEV(type, name) \
setup.register_dev(# type, # name);
#define NET_CONNECT(_name, _input, _output) \
setup.register_link(# _name "." # _input, # _output);
#define NET_CONNECT(name, input, output) \
setup.register_link(# name "." # input, # output);
#define NET_C(_term1, ...) \
setup.register_link_arr( #_term1 ", " # __VA_ARGS__);
#define NET_C(term1, ...) \
setup.register_link_arr( # term1 ", " # __VA_ARGS__);
#define PARAM(_name, _val) \
setup.register_param(# _name, _val);
#define PARAM(name, val) \
setup.register_param(# name, val);
#define NETDEV_PARAMI(_name, _param, _val) \
setup.register_param(# _name "." # _param, _val);
#define NETDEV_PARAMI(name, param, val) \
setup.register_param(# name "." # param, val);
#define NETLIST_NAME(_name) netlist ## _ ## _name
#define NETLIST_NAME(name) netlist ## _ ## name
#define NETLIST_EXTERNAL(_name) \
ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup);
#define NETLIST_EXTERNAL(name) \
ATTR_COLD void NETLIST_NAME(name)(netlist::setup_t &setup);
#define NETLIST_START(_name) \
ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup) \
#define NETLIST_START(name) \
ATTR_COLD void NETLIST_NAME(name)(netlist::setup_t &setup) \
{
#define NETLIST_END() }
#define LOCAL_SOURCE(_name) \
setup.register_source(std::make_shared<netlist::source_proc_t>(# _name, &NETLIST_NAME(_name)));
#define LOCAL_SOURCE(name) \
setup.register_source(std::make_shared<netlist::source_proc_t>(# name, &NETLIST_NAME(name)));
#define LOCAL_LIB_ENTRY(_name) \
LOCAL_SOURCE(_name) \
setup.register_lib_entry(# _name);
#define LOCAL_LIB_ENTRY(name) \
LOCAL_SOURCE(name) \
setup.register_lib_entry(# name);
#define INCLUDE(_name) \
setup.include(# _name);
#define INCLUDE(name) \
setup.include(# name);
#define SUBMODEL(_model, _name) \
setup.namespace_push(# _name); \
NETLIST_NAME(_model)(setup); \
#define SUBMODEL(model, name) \
setup.namespace_push(# name); \
NETLIST_NAME(model)(setup); \
setup.namespace_pop();
// ----------------------------------------------------------------------------------------

6
src/lib/netlist/nl_time.h
View File

@ -14,9 +14,9 @@
// MACROS
//============================================================
#define NLTIME_FROM_NS(_t) netlist_time::from_nsec(_t)
#define NLTIME_FROM_US(_t) netlist_time::from_usec(_t)
#define NLTIME_FROM_MS(_t) netlist_time::from_msec(_t)
#define NLTIME_FROM_NS(t) netlist_time::from_nsec(t)
#define NLTIME_FROM_US(t) netlist_time::from_usec(t)
#define NLTIME_FROM_MS(t) netlist_time::from_msec(t)
#define NLTIME_IMMEDIATE netlist_time::from_nsec(1)
// ----------------------------------------------------------------------------------------

4
src/lib/netlist/nl_util.h
View File

@ -33,7 +33,7 @@ public:
if (ret == "")
ret = elem;
else
#ifdef _WIN32
#ifdef WIN32
ret = ret + '\\' + elem;
#else
ret = ret + '/' + elem;
@ -70,7 +70,7 @@ public:
template <typename T>
static T log(const T &x) { return std::log(x); }
#if defined(_MSC_VER) && _MSC_VER < 1800
#if defined(MSC_VER) && MSC_VER < 1800
ATTR_HOT inline static double e_log1p(const double &x) { return nl_math::log(1.0 + x); }
ATTR_HOT inline static float e_log1p(const float &x) { return nl_math::log(1.0 + x); }
#else

42
src/lib/netlist/plib/pconfig.h
View File

@ -23,8 +23,8 @@
#endif
#if (PHAS_INT128)
typedef __uint128_t UINT128;
typedef __int128_t INT128;
typedef _uint128_t UINT128;
typedef _int128_t INT128;
#endif
#define PLIB_NAMESPACE_START() namespace plib {
@ -51,10 +51,10 @@ typedef __int128_t INT128;
//============================================================
// prevent implicit copying
#define P_PREVENT_COPYING(_name) \
private: \
_name(const _name &); \
_name &operator=(const _name &);
#define P_PREVENT_COPYING(name) \
private: \
name(const name &); \
name &operator=(const name &);
//============================================================
// Compiling standalone
@ -77,7 +77,7 @@ typedef __int128_t INT128;
/* does not work in versions over 4.7.x of 32bit MINGW */
#if defined(__MINGW32__) && !defined(__x86_64) && defined(__i386__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
#define PHAS_PMF_INTERNAL 1
#define MEMBER_ABI __thiscall
#define MEMBER_ABI _thiscall
#elif defined(EMSCRIPTEN)
#define PHAS_PMF_INTERNAL 0
#elif defined(__arm__) || defined(__ARMEL__)
@ -112,16 +112,16 @@ typedef unsigned short UINT16;
typedef signed short INT16;
/* 32-bit values */
#ifndef _WINDOWS_H
#ifndef WINDOWS_H
typedef unsigned int UINT32;
typedef signed int INT32;
#endif
/* 64-bit values */
#ifndef _WINDOWS_H
#ifndef WINDOWS_H
#ifdef _MSC_VER
typedef signed __int64 INT64;
typedef unsigned __int64 UINT64;
typedef signed _int64 INT64;
typedef unsigned _int64 UINT64;
#else
typedef uint64_t UINT64;
typedef int64_t INT64;
@ -152,7 +152,7 @@ static inline ticks_t ticks_per_second()
return std::chrono::high_resolution_clock::period::den / std::chrono::high_resolution_clock::period::num;
}
#if defined(__x86_64__) && !defined(__clang__) && !defined(_MSC_VER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6))
#if defined(__x86_64__) && !defined(_clang__) && !defined(_MSC_VER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6))
static inline ticks_t profile_ticks()
{
@ -178,25 +178,25 @@ public:
class generic_class;
using generic_function = void (*)();
template<typename _MemberFunctionType>
mfp(_MemberFunctionType mftp)
template<typename MemberFunctionType>
mfp(MemberFunctionType mftp)
: m_function(0), m_this_delta(0)
{
*reinterpret_cast<_MemberFunctionType *>(this) = mftp;
*reinterpret_cast<MemberFunctionType *>(this) = mftp;
}
// binding helper
template<typename _FunctionType, typename _ObjectType>
_FunctionType update_after_bind(_ObjectType *object)
template<typename FunctionType, typename ObjectType>
FunctionType update_after_bind(ObjectType *object)
{
return reinterpret_cast<_FunctionType>(
return reinterpret_cast<FunctionType>(
convert_to_generic(reinterpret_cast<generic_class *>(object)));
}
template<typename _FunctionType, typename _MemberFunctionType, typename _ObjectType>
static _FunctionType get_mfp(_MemberFunctionType mftp, _ObjectType *object)
template<typename FunctionType, typename MemberFunctionType, typename ObjectType>
static FunctionType get_mfp(MemberFunctionType mftp, ObjectType *object)
{
mfp mfpo(mftp);
return mfpo.update_after_bind<_FunctionType>(object);
return mfpo.update_after_bind<FunctionType>(object);
}
private:

10
src/lib/netlist/plib/pdynlib.cpp
View File

@ -6,7 +6,7 @@
*/
#include <plib/pdynlib.h>
#ifdef _WIN32
#ifdef WIN32
#include "windows.h"
#else
#include <dlfcn.h>
@ -17,7 +17,7 @@ PLIB_NAMESPACE_START()
dynlib::dynlib(const pstring libname)
: m_isLoaded(false), m_lib(nullptr)
{
#ifdef _WIN32
#ifdef WIN32
//fprintf(stderr, "win: loading <%s>\n", libname.cstr());
if (libname != "")
m_lib = LoadLibrary(libname.cstr());
@ -44,7 +44,7 @@ dynlib::dynlib(const pstring path, const pstring libname)
: m_isLoaded(false), m_lib(nullptr)
{
// printf("win: loading <%s>\n", libname.cstr());
#ifdef _WIN32
#ifdef WIN32
if (libname != "")
m_lib = LoadLibrary(libname.cstr());
else
@ -74,7 +74,7 @@ dynlib::~dynlib()
{
if (m_lib != nullptr)
{
#ifdef _WIN32
#ifdef WIN32
#else
dlclose(m_lib);
//printf("Closed %s\n", dlerror());
@ -89,7 +89,7 @@ bool dynlib::isLoaded() const
void *dynlib::getsym_p(const pstring name)
{
#ifdef _WIN32
#ifdef WIN32
return (void *) GetProcAddress((HMODULE) m_lib, name.cstr());
#else
return dlsym(m_lib, name.cstr());

6
src/lib/netlist/plib/pdynlib.h
View File

@ -4,8 +4,8 @@
* pstring.h
*/
#ifndef _PDYNLIB_H_
#define _PDYNLIB_H_
#ifndef PDYNLIB_H_
#define PDYNLIB_H_
#include <cstdarg>
#include <cstddef>
@ -42,4 +42,4 @@ private:
PLIB_NAMESPACE_END()
#endif /* _PSTRING_H_ */
#endif /* PSTRING_H_ */

6
src/lib/netlist/plib/pfmtlog.h
View File

@ -4,8 +4,8 @@
* pfmtlog.h
*/
#ifndef _PFMT_H_
#define _PFMT_H_
#ifndef PFMT_H_
#define PFMT_H_
//#include <cstdarg>
//#include <cstddef>
@ -298,4 +298,4 @@ void plog_channel<L, build_enabled>::vdowrite(const pstring &ls) const
PLIB_NAMESPACE_END()
#endif /* _PSTRING_H_ */
#endif /* PSTRING_H_ */

32
src/lib/netlist/plib/pparser.cpp
View File

@ -22,22 +22,22 @@ pstring ptokenizer::currentline_str()
void ptokenizer::skipeol()
{
pstring::code_t c = _getc();
pstring::code_t c = getc();
while (c)
{
if (c == 10)
{
c = _getc();
c = getc();
if (c != 13)
_ungetc();
ungetc();
return;
}
c = _getc();
c = getc();
}
}
pstring::code_t ptokenizer::_getc()
pstring::code_t ptokenizer::getc()
{
if (m_px >= m_cur_line.len())
{
@ -52,7 +52,7 @@ pstring::code_t ptokenizer::_getc()
return m_cur_line.code_at(m_px++);
}
void ptokenizer::_ungetc()
void ptokenizer::ungetc()
{
m_px--;
}
@ -160,10 +160,10 @@ ptokenizer::token_t ptokenizer::get_token()
ptokenizer::token_t ptokenizer::get_token_internal()
{
/* skip ws */
pstring::code_t c = _getc();
pstring::code_t c = getc();
while (m_whitespace.find(c)>=0)
{
c = _getc();
c = getc();
if (eof())
{
return token_t(ENDOFFILE);
@ -183,9 +183,9 @@ ptokenizer::token_t ptokenizer::get_token_internal()
else if (m_number_chars.find(c)<0)
break;
tokstr += c;
c = _getc();
c = getc();
}
_ungetc();
ungetc();
return token_t(ret, tokstr);
}
else if (m_identifier_chars.find(c)>=0)
@ -194,9 +194,9 @@ ptokenizer::token_t ptokenizer::get_token_internal()
pstring tokstr = "";
while (m_identifier_chars.find(c)>=0) {
tokstr += c;
c = _getc();
c = getc();
}
_ungetc();
ungetc();
token_id_t id = token_id_t(m_tokens.indexof(tokstr));
if (id.id() >= 0)
return token_t(id, tokstr);
@ -208,11 +208,11 @@ ptokenizer::token_t ptokenizer::get_token_internal()
else if (c == m_string)
{
pstring tokstr = "";
c = _getc();
c = getc();
while (c != m_string)
{
tokstr += c;
c = _getc();
c = getc();
}
return token_t(STRING, tokstr);
}
@ -229,9 +229,9 @@ ptokenizer::token_t ptokenizer::get_token_internal()
if (id.id() >= 0)
return token_t(id, tokstr);
}
c = _getc();
c = getc();
}
_ungetc();
ungetc();
token_id_t id = token_id_t(m_tokens.indexof(tokstr));
if (id.id() >= 0)
return token_t(id, tokstr);

4
src/lib/netlist/plib/pparser.h
View File

@ -122,8 +122,8 @@ protected:
private:
void skipeol();
pstring::code_t _getc();
void _ungetc();
pstring::code_t getc();
void ungetc();
bool eof() { return m_strm.eof(); }

6
src/lib/netlist/plib/pstream.h
View File

@ -4,8 +4,8 @@
* pstream.h
*/
#ifndef _PSTREAM_H_
#define _PSTREAM_H_
#ifndef PSTREAM_H_
#define PSTREAM_H_
#include <cstdarg>
#include <cstddef>
@ -379,4 +379,4 @@ private:
PLIB_NAMESPACE_END()
#endif /* _PSTREAM_H_ */
#endif /* PSTREAM_H_ */

4
src/lib/netlist/plib/pstring.cpp
View File

@ -385,7 +385,7 @@ pstr_t *pstring_t<F>::salloc(int n)
stk[sn].pop();
}
// str_t *p = (str_t *) _mm_malloc(size, 8);
// str_t *p = (str_t *) mm_malloc(size, 8);
p->init(n);
return p;
}
@ -425,7 +425,7 @@ pstr_t *pstring_t<F>::salloc(int n)
{
int size = sizeof(pstr_t) + n + 1;
pstr_t *p = (pstr_t *) palloc_array(char, size);
// str_t *p = (str_t *) _mm_malloc(size, 8);
// str_t *p = (str_t *) mm_malloc(size, 8);
p->init(n);
return p;
}

6
src/lib/netlist/plib/pstring.h
View File

@ -4,8 +4,8 @@
* pstring.h
*/
#ifndef _PSTRING_H_
#define _PSTRING_H_
#ifndef PSTRING_H_
#define PSTRING_H_
#include <cstdarg>
#include <cstddef>
@ -378,4 +378,4 @@ private:
};
#endif /* _PSTRING_H_ */
#endif /* PSTRING_H_ */

8
src/lib/netlist/plib/ptypes.h
View File

@ -78,10 +78,10 @@ protected:
PLIB_NAMESPACE_END()
#define P_ENUM(_name, ...) \
struct _name : public plib::enum_base { \
#define P_ENUM(ename, ...) \
struct ename : public plib::enum_base { \
enum e { __VA_ARGS__ }; \
_name (e v) : m_v(v) { } \
ename (e v) : m_v(v) { } \
bool set_from_string (const pstring &s) { \
static const char *strings = # __VA_ARGS__; \
int f = from_string_int(strings, s.cstr()); \
@ -89,7 +89,7 @@ PLIB_NAMESPACE_END()
} \
operator e() const {return m_v;} \
int as_int() const {return (int) m_v;} \
bool operator==(const _name &rhs) const {return m_v == rhs.m_v;} \
bool operator==(const ename &rhs) const {return m_v == rhs.m_v;} \
bool operator==(const e &rhs) const {return m_v == (int) rhs;} \
const pstring name() const { \
static const char *strings = # __VA_ARGS__; \

8
src/lib/netlist/solver/mat_cr.h
View File

@ -13,13 +13,13 @@
#include <algorithm>
#include "plib/pconfig.h"
template<int _storage_N>
template<int storage_N>
struct mat_cr_t
{
unsigned nz_num;
unsigned ia[_storage_N + 1];
unsigned ja[_storage_N * _storage_N];
unsigned diag[_storage_N]; /* n */
unsigned ia[storage_N + 1];
unsigned ja[storage_N * storage_N];
unsigned diag[storage_N]; /* n */
template<typename T>
void mult_vec(const T * RESTRICT A, const T * RESTRICT x, T * RESTRICT res)

56
src/lib/netlist/solver/nld_ms_direct.h
View File

@ -28,7 +28,7 @@
NETLIB_NAMESPACE_DEVICES_START()
//#define nl_ext_double __float128 // slow, very slow
//#define nl_ext_double _float128 // slow, very slow
//#define nl_ext_double long double // slightly slower
#define nl_ext_double nl_double
@ -46,7 +46,7 @@ struct ti_t
volatile std::atomic<int> lo;
thr_intf *intf;
void *params;
// int _block[29]; /* make it 256 bytes */
// int block[29]; /* make it 256 bytes */
};
static ti_t ti[MAXTHR];
@ -111,7 +111,7 @@ static void thr_dispose()
}
#endif
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
#if TEST_PARALLEL
class matrix_solver_direct_t: public matrix_solver_t, public thr_intf
#else
@ -158,18 +158,18 @@ protected:
template <typename T1>
inline nl_ext_double &RHS(const T1 &r) { return m_A[r][N()]; }
#endif
ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents
private:
static const std::size_t m_pitch = (((_storage_N + 1) + 7) / 8) * 8;
//static const std::size_t m_pitch = (((_storage_N + 1) + 15) / 16) * 16;
//static const std::size_t m_pitch = (((_storage_N + 1) + 31) / 32) * 32;
static const std::size_t m_pitch = (((storage_N + 1) + 7) / 8) * 8;
//static const std::size_t m_pitch = (((storage_N + 1) + 15) / 16) * 16;
//static const std::size_t m_pitch = (((storage_N + 1) + 31) / 32) * 32;
#if (NL_USE_DYNAMIC_ALLOCATION)
ATTR_ALIGN nl_ext_double * RESTRICT m_A;
#else
ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch];
#endif
//ATTR_ALIGN nl_ext_double m_RHSx[_storage_N];
//ATTR_ALIGN nl_ext_double m_RHSx[storage_N];
const unsigned m_dim;
@ -179,8 +179,8 @@ private:
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t()
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::~matrix_solver_direct_t()
{
#if (NL_USE_DYNAMIC_ALLOCATION)
pfree_array(m_A);
@ -190,8 +190,8 @@ matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t()
#endif
}
template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
if (m_dim < nets.size())
log().fatal("Dimension {1} less than {2}", m_dim, nets.size());
@ -220,8 +220,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis
#if TEST_PARALLEL
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::do_work(const int id, void *param)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::do_work(const int id, void *param)
{
const int i = x_i[id];
/* FIXME: Singular matrix? */
@ -244,8 +244,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::do_work(const int id, void *param)
}
#endif
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::LE_solve()
{
const unsigned kN = N();
@ -340,9 +340,9 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
}
}
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
template <typename T>
void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
void matrix_solver_direct_t<m_N, storage_N>::LE_back_subst(
T * RESTRICT x)
{
const unsigned kN = N();
@ -378,10 +378,10 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
{
nl_double new_V[_storage_N]; // = { 0.0 };
nl_double new_V[storage_N]; // = { 0.0 };
this->LE_solve();
this->LE_back_subst(new_V);
@ -401,8 +401,8 @@ int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const
}
}
template <unsigned m_N, unsigned _storage_N>
inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
inline int matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
build_LE_A<matrix_solver_direct_t>();
build_LE_RHS<matrix_solver_direct_t>();
@ -414,8 +414,8 @@ inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const boo
return this->solve_non_dynamic(newton_raphson);
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, ASCENDING, params)
, m_dim(size)
@ -432,8 +432,8 @@ matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetl
#endif
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, sort, params)
, m_dim(size)

80
src/lib/netlist/solver/nld_ms_direct_lu.h
View File

@ -13,15 +13,15 @@
#include "solver/nld_solver.h"
#include "solver/nld_matrix_solver.h"
//#define A(_r, _c) m_A[_r][_c]
//#define A(r, c) m_A[_r][_c]
NETLIB_NAMESPACE_DEVICES_START()
//#define nl_ext_double __float128 // slow, very slow
//#define nl_ext_double _float128 // slow, very slow
//#define nl_ext_double long double // slightly slower
#define nl_ext_double double
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_direct_t: public matrix_solver_t
{
public:
@ -54,7 +54,7 @@ protected:
const unsigned * const p = m_terms[k]->m_nzrd.data();
const unsigned e = m_terms[k]->m_nzrd.size();
for (int i = k+1; i < _storage_N;i++)
for (int i = k+1; i < storage_N;i++)
{
const double alpha = A(i,k) * akki;
A(i,k) = alpha;
@ -72,7 +72,7 @@ protected:
const unsigned kN = N();
unsigned sk = 1;
if (1 && kN == _storage_N)
if (1 && kN == storage_N)
{
if (kN> 0 ) LEk<0>();
if (kN> 1 ) LEk<1>();
@ -139,15 +139,15 @@ protected:
template <typename T1, typename T2>
inline nl_ext_double &A(const T1 r, const T2 c) { return m_A[r][c]; }
//ATTR_ALIGN nl_double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
ATTR_ALIGN nl_double m_RHS[_storage_N];
ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_double m_last_V[_storage_N];
//ATTR_ALIGN nl_double m_A[storage_N][((storage_N + 7) / 8) * 8];
ATTR_ALIGN nl_double m_RHS[storage_N];
ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_double m_last_V[storage_N];
terms_t *m_rails_temp;
private:
ATTR_ALIGN nl_ext_double m_A[_storage_N][((_storage_N + 7) / 8) * 8];
ATTR_ALIGN nl_ext_double m_A[storage_N][((storage_N + 7) / 8) * 8];
const unsigned m_dim;
nl_double m_lp_fact;
@ -157,14 +157,14 @@ private:
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::~matrix_solver_direct_t()
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::~matrix_solver_direct_t()
{
pfree_array(m_rails_temp);
}
template <unsigned m_N, unsigned _storage_N>
nl_double matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
template <unsigned m_N, unsigned storage_N>
nl_double matrix_solver_direct_t<m_N, storage_N>::compute_next_timestep()
{
nl_double new_solver_timestep = m_params.m_max_timestep;
@ -202,8 +202,8 @@ nl_double matrix_solver_direct_t<m_N, _storage_N>::compute_next_timestep()
return new_solver_timestep;
}
template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, terminal_t *term)
template <unsigned m_N, unsigned storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::add_term(int k, terminal_t *term)
{
if (term->m_otherterm->net().isRailNet())
{
@ -226,8 +226,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, terminal
}
template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
ATTR_COLD void matrix_solver_direct_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
if (m_dim < nets.size())
netlist().error("Dimension {1} less than {2}", m_dim,nets.size());
@ -365,8 +365,8 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis
}
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::build_LE_A()
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::build_LE_A()
{
const unsigned iN = N();
for (unsigned k = 0; k < iN; k++)
@ -391,8 +391,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::build_LE_A()
}
}
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::build_LE_RHS(nl_double * RESTRICT rhs)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::build_LE_RHS(nl_double * RESTRICT rhs)
{
const unsigned iN = N();
for (unsigned k = 0; k < iN; k++)
@ -419,8 +419,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::build_LE_RHS(nl_double * RESTRICT
#if 1
#else
// Crout algo
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::LE_solve()
{
const unsigned kN = N();
@ -428,7 +428,7 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
ATTR_UNUSED double big,temp;
#if 0
double vv[_storage_N];
double vv[storage_N];
for (i=0;i<kN;i++)
{
@ -501,8 +501,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
}
#endif
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::LE_back_subst(
nl_double * RESTRICT x)
{
const unsigned kN = N();
@ -535,8 +535,8 @@ void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
}
template <unsigned m_N, unsigned _storage_N>
nl_double matrix_solver_direct_t<m_N, _storage_N>::delta(
template <unsigned m_N, unsigned storage_N>
nl_double matrix_solver_direct_t<m_N, storage_N>::delta(
const nl_double * RESTRICT V)
{
/* FIXME: Ideally we should also include currents (RHS) here. This would
@ -551,8 +551,8 @@ nl_double matrix_solver_direct_t<m_N, _storage_N>::delta(
return cerr;
}
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_direct_t<m_N, _storage_N>::store(
template <unsigned m_N, unsigned storage_N>
void matrix_solver_direct_t<m_N, storage_N>::store(
const nl_double * RESTRICT V)
{
for (unsigned i = 0, iN=N(); i < iN; i++)
@ -562,10 +562,10 @@ void matrix_solver_direct_t<m_N, _storage_N>::store(
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
{
nl_double new_V[_storage_N]; // = { 0.0 };
nl_double new_V[storage_N]; // = { 0.0 };
this->LE_back_subst(new_V);
@ -584,8 +584,8 @@ int matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const
}
}
template <unsigned m_N, unsigned _storage_N>
inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
inline int matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
this->build_LE_A();
this->build_LE_RHS(m_last_RHS);
@ -596,8 +596,8 @@ inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const boo
return this->solve_non_dynamic(newton_raphson);
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_parameters_t *params, const int size)
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(const solver_parameters_t *params, const int size)
: matrix_solver_t(GAUSSIAN_ELIMINATION, params)
, m_dim(size)
, m_lp_fact(0)
@ -610,8 +610,8 @@ matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_par
}
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const eSolverType type, const solver_parameters_t *params, const int size)
template <unsigned m_N, unsigned storage_N>
matrix_solver_direct_t<m_N, storage_N>::matrix_solver_direct_t(const eSolverType type, const solver_parameters_t *params, const int size)
: matrix_solver_t(type, params)
, m_dim(size)
, m_lp_fact(0)

50
src/lib/netlist/solver/nld_ms_gcr.h
View File

@ -25,7 +25,7 @@
NETLIB_NAMESPACE_DEVICES_START()
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_GCR_t: public matrix_solver_t
{
public:
@ -65,9 +65,9 @@ private:
}
unsigned m_dim;
plib::pvector_t<int> m_term_cr[_storage_N];
mat_cr_t<_storage_N> mat;
nl_double m_A[_storage_N * _storage_N];
plib::pvector_t<int> m_term_cr[storage_N];
mat_cr_t<storage_N> mat;
nl_double m_A[storage_N * storage_N];
extsolver m_proc;
@ -77,8 +77,8 @@ private:
// matrix_solver - GMRES
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_GCR_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
setup_base(nets);
@ -87,7 +87,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
/* build the final matrix */
bool touched[_storage_N][_storage_N] = { { false } };
bool touched[storage_N][storage_N] = { { false } };
for (unsigned k = 0; k < iN; k++)
{
for (auto & j : this->m_terms[k]->m_nz)
@ -178,8 +178,8 @@ void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
}
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(plib::postream &strm)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_GCR_t<m_N, storage_N>::csc_private(plib::postream &strm)
{
const unsigned iN = N();
for (unsigned i = 0; i < iN - 1; i++)
@ -223,25 +223,25 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(plib::postream &strm)
}
}
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_GCR_t<m_N, _storage_N>::create_solver_code(plib::postream &strm)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_GCR_t<m_N, storage_N>::create_solver_code(plib::postream &strm)
{
//const unsigned iN = N();
strm.writeline(plib::pfmt("extern \"C\" void {1}(double * __restrict m_A, double * __restrict RHS)")(static_compile_name()));
strm.writeline(plib::pfmt("extern \"C\" void {1}(double * _restrict m_A, double * _restrict RHS)")(static_compile_name()));
strm.writeline("{");
csc_private(strm);
strm.writeline("}");
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_GCR_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
const unsigned iN = this->N();
ATTR_ALIGN nl_double RHS[_storage_N];
ATTR_ALIGN nl_double new_V[_storage_N];
ATTR_ALIGN nl_double RHS[storage_N];
ATTR_ALIGN nl_double new_V[storage_N];
for (unsigned i=0, e=mat.nz_num; i<e; i++)
m_A[i] = 0.0;
@ -260,16 +260,16 @@ int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r
const nl_double * const * RESTRICT other_cur_analog = t->other_curanalog();
#if (0 ||NL_USE_SSE)
__m128d mg = _mm_set_pd(0.0, 0.0);
__m128d mr = _mm_set_pd(0.0, 0.0);
__m128d mg = mm_set_pd(0.0, 0.0);
__m128d mr = mm_set_pd(0.0, 0.0);
unsigned i = 0;
for (; i < term_count - 1; i+=2)
{
mg = _mm_add_pd(mg, _mm_loadu_pd(&gt[i]));
mr = _mm_add_pd(mr, _mm_loadu_pd(&Idr[i]));
mg = mm_add_pd(mg, mm_loadu_pd(&gt[i]));
mr = mm_add_pd(mr, mm_loadu_pd(&Idr[i]));
}
gtot_t = _mm_cvtsd_f64(mg) + _mm_cvtsd_f64(_mm_unpackhi_pd(mg,mg));
RHS_t = _mm_cvtsd_f64(mr) + _mm_cvtsd_f64(_mm_unpackhi_pd(mr,mr));
gtot_t = mm_cvtsd_f64(mg) + mm_cvtsd_f64(mm_unpackhi_pd(mg,mg));
RHS_t = mm_cvtsd_f64(mr) + mm_cvtsd_f64(mm_unpackhi_pd(mr,mr));
for (; i < term_count; i++)
{
gtot_t += gt[i];
@ -353,16 +353,16 @@ int matrix_solver_GCR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r
//__builtin_prefetch(&new_V[j-1], 1);
//if (j>0)__builtin_prefetch(&m_A[mat.diag[j-1]], 0);
#if (NL_USE_SSE)
__m128d tmp = _mm_set_pd1(0.0);
__m128d tmp = mm_set_pd1(0.0);
const unsigned e = mat.ia[j+1];
unsigned pk = mat.diag[j] + 1;
for (; pk < e - 1; pk+=2)
{
//tmp += m_A[pk] * new_V[mat.ja[pk]];
tmp = _mm_add_pd(tmp, _mm_mul_pd(_mm_set_pd(m_A[pk], m_A[pk+1]),
tmp = mm_add_pd(tmp, mm_mul_pd(mm_set_pd(m_A[pk], m_A[pk+1]),
_mm_set_pd(new_V[mat.ja[pk]], new_V[mat.ja[pk+1]])));
}
double tmpx = _mm_cvtsd_f64(tmp) + _mm_cvtsd_f64(_mm_unpackhi_pd(tmp,tmp));
double tmpx = mm_cvtsd_f64(tmp) + mm_cvtsd_f64(mm_unpackhi_pd(tmp,tmp));
for (; pk < e; pk++)
{
tmpx += m_A[pk] * new_V[mat.ja[pk]];

54
src/lib/netlist/solver/nld_ms_gmres.h
View File

@ -21,13 +21,13 @@
NETLIB_NAMESPACE_DEVICES_START()
template <unsigned m_N, unsigned _storage_N>
class matrix_solver_GMRES_t: public matrix_solver_direct_t<m_N, _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_GMRES_t: public matrix_solver_direct_t<m_N, storage_N>
{
public:
matrix_solver_GMRES_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
: matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
, m_use_iLU_preconditioning(true)
, m_use_more_precise_stop_condition(false)
, m_accuracy_mult(1.0)
@ -45,23 +45,23 @@ private:
int solve_ilu_gmres(nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy);
plib::pvector_t<int> m_term_cr[_storage_N];
plib::pvector_t<int> m_term_cr[storage_N];
bool m_use_iLU_preconditioning;
bool m_use_more_precise_stop_condition;
nl_double m_accuracy_mult; // FXIME: Save state
mat_cr_t<_storage_N> mat;
mat_cr_t<storage_N> mat;
nl_double m_A[_storage_N * _storage_N];
nl_double m_LU[_storage_N * _storage_N];
nl_double m_A[storage_N * storage_N];
nl_double m_LU[storage_N * storage_N];
nl_double m_c[_storage_N + 1]; /* mr + 1 */
nl_double m_g[_storage_N + 1]; /* mr + 1 */
nl_double m_ht[_storage_N + 1][_storage_N]; /* (mr + 1), mr */
nl_double m_s[_storage_N + 1]; /* mr + 1 */
nl_double m_v[_storage_N + 1][_storage_N]; /*(mr + 1), n */
nl_double m_y[_storage_N + 1]; /* mr + 1 */
nl_double m_c[storage_N + 1]; /* mr + 1 */
nl_double m_g[storage_N + 1]; /* mr + 1 */
nl_double m_ht[storage_N + 1][storage_N]; /* (mr + 1), mr */
nl_double m_s[storage_N + 1]; /* mr + 1 */
nl_double m_v[storage_N + 1][storage_N]; /*(mr + 1), n */
nl_double m_y[storage_N + 1]; /* mr + 1 */
};
@ -69,10 +69,10 @@ private:
// matrix_solver - GMRES
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_GMRES_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
matrix_solver_direct_t<m_N, storage_N>::vsetup(nets);
unsigned nz = 0;
const unsigned iN = this->N();
@ -108,8 +108,8 @@ void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
mat.nz_num = nz;
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_GMRES_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
const unsigned iN = this->N();
@ -122,8 +122,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton
*/
//nz_num = 0;
ATTR_ALIGN nl_double RHS[_storage_N];
ATTR_ALIGN nl_double new_V[_storage_N];
ATTR_ALIGN nl_double RHS[storage_N];
ATTR_ALIGN nl_double new_V[storage_N];
for (unsigned i=0, e=mat.nz_num; i<e; i++)
m_A[i] = 0.0;
@ -179,7 +179,7 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton
if (gsl>=failed)
{
this->m_iterative_fail++;
return matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(newton_raphson);
return matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(newton_raphson);
}
if (newton_raphson)
@ -207,8 +207,8 @@ inline void givens_mult( const T & c, const T & s, T & g0, T & g1 )
g1 = tg1;
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_GMRES_t<m_N, storage_N>::solve_ilu_gmres (nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy)
{
/*-------------------------------------------------------------------------
* The code below was inspired by code published by John Burkardt under
@ -253,8 +253,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRIC
* differently: The invest doesn't pay off.
* Therefore we use the approach in the else part.
*/
nl_double t[_storage_N];
nl_double Ax[_storage_N];
nl_double t[storage_N];
nl_double Ax[storage_N];
vec_set(n, accuracy, t);
mat.mult_vec(m_A, t, Ax);
mat.solveLUx(m_LU, Ax);
@ -272,8 +272,8 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (nl_double * RESTRIC
nl_double mu;
nl_double rho;
nl_double Ax[_storage_N];
nl_double residual[_storage_N];
nl_double Ax[storage_N];
nl_double residual[storage_N];
mat.mult_vec(m_A, x, Ax);

52
src/lib/netlist/solver/nld_ms_sm.h
View File

@ -41,11 +41,11 @@
NETLIB_NAMESPACE_DEVICES_START()
//#define nl_ext_double __float128 // slow, very slow
//#define nl_ext_double _float128 // slow, very slow
//#define nl_ext_double long double // slightly slower
#define nl_ext_double nl_double
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_sm_t: public matrix_solver_t
{
friend class matrix_solver_t;
@ -87,19 +87,19 @@ protected:
template <typename T1, typename T2>
inline nl_ext_double &lAinv(const T1 &r, const T2 &c) { return m_lAinv[r][c]; }
ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents
private:
static const std::size_t m_pitch = ((( _storage_N) + 7) / 8) * 8;
ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_Ainv[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_W[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_RHS[_storage_N]; // right hand side - contains currents
static const std::size_t m_pitch = ((( storage_N) + 7) / 8) * 8;
ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_Ainv[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_W[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_RHS[storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_ext_double m_lA[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_lAinv[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_lA[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_lAinv[storage_N][m_pitch];
//ATTR_ALIGN nl_ext_double m_RHSx[_storage_N];
//ATTR_ALIGN nl_ext_double m_RHSx[storage_N];
const unsigned m_dim;
@ -109,16 +109,16 @@ private:
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
matrix_solver_sm_t<m_N, _storage_N>::~matrix_solver_sm_t()
template <unsigned m_N, unsigned storage_N>
matrix_solver_sm_t<m_N, storage_N>::~matrix_solver_sm_t()
{
#if (NL_USE_DYNAMIC_ALLOCATION)
pfree_array(m_A);
#endif
}
template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
ATTR_COLD void matrix_solver_sm_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
if (m_dim < nets.size())
log().fatal("Dimension {1} less than {2}", m_dim, nets.size());
@ -138,8 +138,8 @@ ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_sm_t<m_N, _storage_N>::LE_invert()
template <unsigned m_N, unsigned storage_N>
void matrix_solver_sm_t<m_N, storage_N>::LE_invert()
{
const unsigned kN = N();
@ -201,9 +201,9 @@ void matrix_solver_sm_t<m_N, _storage_N>::LE_invert()
}
}
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
template <typename T>
void matrix_solver_sm_t<m_N, _storage_N>::LE_compute_x(
void matrix_solver_sm_t<m_N, storage_N>::LE_compute_x(
T * RESTRICT x)
{
const unsigned kN = N();
@ -221,14 +221,14 @@ void matrix_solver_sm_t<m_N, _storage_N>::LE_compute_x(
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_sm_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_sm_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
{
static const bool incremental = true;
static unsigned cnt = 0;
const auto iN = N();
nl_double new_V[_storage_N]; // = { 0.0 };
nl_double new_V[storage_N]; // = { 0.0 };
if (0 || ((cnt % 200) == 0))
{
@ -311,8 +311,8 @@ int matrix_solver_sm_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const boo
}
}
template <unsigned m_N, unsigned _storage_N>
inline int matrix_solver_sm_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
inline int matrix_solver_sm_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
build_LE_A<matrix_solver_sm_t>();
build_LE_RHS<matrix_solver_sm_t>();
@ -324,8 +324,8 @@ inline int matrix_solver_sm_t<m_N, _storage_N>::vsolve_non_dynamic(const bool ne
return this->solve_non_dynamic(newton_raphson);
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_sm_t<m_N, _storage_N>::matrix_solver_sm_t(netlist_t &anetlist, const pstring &name,
template <unsigned m_N, unsigned storage_N>
matrix_solver_sm_t<m_N, storage_N>::matrix_solver_sm_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, NOSORT, params)
, m_dim(size)

26
src/lib/netlist/solver/nld_ms_sor.h
View File

@ -19,13 +19,13 @@
NETLIB_NAMESPACE_DEVICES_START()
template <unsigned m_N, unsigned _storage_N>
class matrix_solver_SOR_t: public matrix_solver_direct_t<m_N, _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_SOR_t: public matrix_solver_direct_t<m_N, storage_N>
{
public:
matrix_solver_SOR_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
: matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
, m_lp_fact(0)
{
}
@ -44,15 +44,15 @@ private:
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_SOR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_SOR_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
matrix_solver_direct_t<m_N, storage_N>::vsetup(nets);
this->save(NLNAME(m_lp_fact));
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_SOR_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
const unsigned iN = this->N();
bool resched = false;
@ -68,10 +68,10 @@ int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r
const nl_double ws = this->m_params.m_sor;
ATTR_ALIGN nl_double w[_storage_N];
ATTR_ALIGN nl_double one_m_w[_storage_N];
ATTR_ALIGN nl_double RHS[_storage_N];
ATTR_ALIGN nl_double new_V[_storage_N];
ATTR_ALIGN nl_double w[storage_N];
ATTR_ALIGN nl_double one_m_w[storage_N];
ATTR_ALIGN nl_double RHS[storage_N];
ATTR_ALIGN nl_double new_V[storage_N];
for (unsigned k = 0; k < iN; k++)
{
@ -163,7 +163,7 @@ int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_r
{
// Fallback to direct solver ...
this->m_iterative_fail++;
return matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(newton_raphson);
return matrix_solver_direct_t<m_N, storage_N>::vsolve_non_dynamic(newton_raphson);
}
this->m_stat_calculations++;

26
src/lib/netlist/solver/nld_ms_sor_mat.h
View File

@ -20,15 +20,15 @@
NETLIB_NAMESPACE_DEVICES_START()
template <unsigned m_N, unsigned _storage_N>
class matrix_solver_SOR_mat_t: public matrix_solver_direct_t<m_N, _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_SOR_mat_t: public matrix_solver_direct_t<m_N, storage_N>
{
friend class matrix_solver_t;
public:
matrix_solver_SOR_mat_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::DESCENDING, params, size)
: matrix_solver_direct_t<m_N, storage_N>(anetlist, name, matrix_solver_t::DESCENDING, params, size)
, m_omega(params->m_sor)
, m_lp_fact(0)
, m_gs_fail(0)
@ -43,7 +43,7 @@ public:
virtual int vsolve_non_dynamic(const bool newton_raphson) override;
private:
nl_double m_Vdelta[_storage_N];
nl_double m_Vdelta[storage_N];
nl_double m_omega;
nl_double m_lp_fact;
@ -55,10 +55,10 @@ private:
// matrix_solver - Gauss - Seidel
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
void matrix_solver_SOR_mat_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
matrix_solver_direct_t<m_N, storage_N>::vsetup(nets);
this->save(NLNAME(m_omega));
this->save(NLNAME(m_lp_fact));
this->save(NLNAME(m_gs_fail));
@ -68,8 +68,8 @@ void matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets
#if 0
//FIXME: move to solve_base
template <unsigned m_N, unsigned _storage_N>
nl_double matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve()
template <unsigned m_N, unsigned storage_N>
nl_double matrix_solver_SOR_mat_t<m_N, storage_N>::vsolve()
{
/*
* enable linear prediction on first newton pass
@ -115,8 +115,8 @@ nl_double matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve()
}
#endif
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_SOR_mat_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
/* The matrix based code looks a lot nicer but actually is 30% slower than
* the optimized code which works directly on the data structures.
@ -124,7 +124,7 @@ int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newt
*/
ATTR_ALIGN nl_double new_v[_storage_N] = { 0.0 };
ATTR_ALIGN nl_double new_v[storage_N] = { 0.0 };
const unsigned iN = this->N();
matrix_solver_t::build_LE_A<matrix_solver_SOR_mat_t>();
@ -208,7 +208,7 @@ int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newt
//this->netlist().warning("Falling back to direct solver .. Consider increasing RESCHED_LOOPS");
this->m_gs_fail++;
return matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(newton_raphson);
return matrix_solver_direct_t<m_N, storage_N>::solve_non_dynamic(newton_raphson);
}
else {
this->store(new_v);

62
src/lib/netlist/solver/nld_ms_w.h
View File

@ -48,11 +48,11 @@
NETLIB_NAMESPACE_DEVICES_START()
//#define nl_ext_double __float128 // slow, very slow
//#define nl_ext_double _float128 // slow, very slow
//#define nl_ext_double long double // slightly slower
#define nl_ext_double nl_double
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
class matrix_solver_w_t: public matrix_solver_t
{
friend class matrix_solver_t;
@ -92,26 +92,26 @@ protected:
template <typename T1, typename T2>
inline nl_ext_double &lA(const T1 &r, const T2 &c) { return m_lA[r][c]; }
ATTR_ALIGN nl_double m_last_RHS[_storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_double m_last_RHS[storage_N]; // right hand side - contains currents
private:
static const std::size_t m_pitch = ((( _storage_N) + 7) / 8) * 8;
ATTR_ALIGN nl_ext_double m_A[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_Ainv[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_W[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_RHS[_storage_N]; // right hand side - contains currents
static const std::size_t m_pitch = ((( storage_N) + 7) / 8) * 8;
ATTR_ALIGN nl_ext_double m_A[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_Ainv[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_W[storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_RHS[storage_N]; // right hand side - contains currents
ATTR_ALIGN nl_ext_double m_lA[_storage_N][m_pitch];
ATTR_ALIGN nl_ext_double m_lA[storage_N][m_pitch];
/* temporary */
ATTR_ALIGN nl_double H[_storage_N][m_pitch] ;
unsigned rows[_storage_N];
unsigned cols[_storage_N][m_pitch];
unsigned colcount[_storage_N];
ATTR_ALIGN nl_double H[storage_N][m_pitch] ;
unsigned rows[storage_N];
unsigned cols[storage_N][m_pitch];
unsigned colcount[storage_N];
unsigned m_cnt;
//ATTR_ALIGN nl_ext_double m_RHSx[_storage_N];
//ATTR_ALIGN nl_ext_double m_RHSx[storage_N];
const unsigned m_dim;
@ -121,13 +121,13 @@ private:
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <unsigned m_N, unsigned _storage_N>
matrix_solver_w_t<m_N, _storage_N>::~matrix_solver_w_t()
template <unsigned m_N, unsigned storage_N>
matrix_solver_w_t<m_N, storage_N>::~matrix_solver_w_t()
{
}
template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
template <unsigned m_N, unsigned storage_N>
ATTR_COLD void matrix_solver_w_t<m_N, storage_N>::vsetup(analog_net_t::list_t &nets)
{
if (m_dim < nets.size())
log().fatal("Dimension {1} less than {2}", m_dim, nets.size());
@ -147,8 +147,8 @@ ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &
template <unsigned m_N, unsigned _storage_N>
void matrix_solver_w_t<m_N, _storage_N>::LE_invert()
template <unsigned m_N, unsigned storage_N>
void matrix_solver_w_t<m_N, storage_N>::LE_invert()
{
const unsigned kN = N();
@ -209,9 +209,9 @@ void matrix_solver_w_t<m_N, _storage_N>::LE_invert()
}
}
template <unsigned m_N, unsigned _storage_N>
template <unsigned m_N, unsigned storage_N>
template <typename T>
void matrix_solver_w_t<m_N, _storage_N>::LE_compute_x(
void matrix_solver_w_t<m_N, storage_N>::LE_compute_x(
T * RESTRICT x)
{
const unsigned kN = N();
@ -229,12 +229,12 @@ void matrix_solver_w_t<m_N, _storage_N>::LE_compute_x(
}
template <unsigned m_N, unsigned _storage_N>
int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
int matrix_solver_w_t<m_N, storage_N>::solve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
{
const auto iN = N();
nl_double new_V[_storage_N]; // = { 0.0 };
nl_double new_V[storage_N]; // = { 0.0 };
if ((m_cnt % 100) == 0)
{
@ -272,7 +272,7 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool
/* construct w = transform(V) * y
* dim: rowcount x iN
* */
nl_double w[_storage_N];
nl_double w[storage_N];
for (unsigned i = 0; i < rowcount; i++)
{
const unsigned r = rows[i];
@ -322,7 +322,7 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool
}
/* Back substitution */
//inv(H) w = t w = H t
nl_double t[_storage_N]; // FIXME: convert to member
nl_double t[storage_N]; // FIXME: convert to member
for (int j = rowcount - 1; j >= 0; j--)
{
nl_double tmp = 0;
@ -375,8 +375,8 @@ int matrix_solver_w_t<m_N, _storage_N>::solve_non_dynamic(ATTR_UNUSED const bool
}
}
template <unsigned m_N, unsigned _storage_N>
inline int matrix_solver_w_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
template <unsigned m_N, unsigned storage_N>
inline int matrix_solver_w_t<m_N, storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
build_LE_A<matrix_solver_w_t>();
build_LE_RHS<matrix_solver_w_t>();
@ -388,8 +388,8 @@ inline int matrix_solver_w_t<m_N, _storage_N>::vsolve_non_dynamic(const bool new
return this->solve_non_dynamic(newton_raphson);
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_w_t<m_N, _storage_N>::matrix_solver_w_t(netlist_t &anetlist, const pstring &name,
template <unsigned m_N, unsigned storage_N>
matrix_solver_w_t<m_N, storage_N>::matrix_solver_w_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, NOSORT, params)
,m_cnt(0)

18
src/lib/netlist/solver/nld_solver.cpp
View File

@ -622,7 +622,7 @@ NETLIB_UPDATE(solver)
}
}
template <int m_N, int _storage_N>
template <int m_N, int storage_N>
matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_specific)
{
pstring solvername = plib::pfmt("Solver_{1}")(m_mat_solvers.size());
@ -636,39 +636,39 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
{
if (pstring("SOR_MAT").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_mat_t<m_N,_storage_N> solver_sor_mat;
typedef matrix_solver_SOR_mat_t<m_N,storage_N> solver_sor_mat;
return plib::palloc<solver_sor_mat>(netlist(), solvername, &m_params, size);
}
else if (pstring("MAT_CR").equals(m_iterative_solver))
{
typedef matrix_solver_GCR_t<m_N,_storage_N> solver_mat;
typedef matrix_solver_GCR_t<m_N,storage_N> solver_mat;
return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size);
}
else if (pstring("MAT").equals(m_iterative_solver))
{
typedef matrix_solver_direct_t<m_N,_storage_N> solver_mat;
typedef matrix_solver_direct_t<m_N,storage_N> solver_mat;
return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size);
}
else if (pstring("SM").equals(m_iterative_solver))
{
/* Sherman-Morrison Formula */
typedef matrix_solver_sm_t<m_N,_storage_N> solver_mat;
typedef matrix_solver_sm_t<m_N,storage_N> solver_mat;
return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size);
}
else if (pstring("W").equals(m_iterative_solver))
{
/* Woodbury Formula */
typedef matrix_solver_w_t<m_N,_storage_N> solver_mat;
typedef matrix_solver_w_t<m_N,storage_N> solver_mat;
return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size);
}
else if (pstring("SOR").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_t<m_N,_storage_N> solver_GS;
typedef matrix_solver_SOR_t<m_N,storage_N> solver_GS;
return plib::palloc<solver_GS>(netlist(), solvername, &m_params, size);
}
else if (pstring("GMRES").equals(m_iterative_solver))
{
typedef matrix_solver_GMRES_t<m_N,_storage_N> solver_GMRES;
typedef matrix_solver_GMRES_t<m_N,storage_N> solver_GMRES;
return plib::palloc<solver_GMRES>(netlist(), solvername, &m_params, size);
}
else
@ -679,7 +679,7 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
}
else
{
typedef matrix_solver_direct_t<m_N,_storage_N> solver_D;
typedef matrix_solver_direct_t<m_N,storage_N> solver_D;
return plib::palloc<solver_D>(netlist(), solvername, &m_params, size);
}
}

8
src/lib/netlist/solver/nld_solver.h
View File

@ -19,9 +19,9 @@
// Macros
// ----------------------------------------------------------------------------------------
#define SOLVER(_name, _freq) \
NET_REGISTER_DEV(SOLVER, _name) \
PARAM(_name.FREQ, _freq)
#define SOLVER(name, freq) \
NET_REGISTER_DEV(SOLVER, name) \
PARAM(name.FREQ, freq)
// ----------------------------------------------------------------------------------------
// solver
@ -125,7 +125,7 @@ private:
solver_parameters_t m_params;
template <int m_N, int _storage_N>
template <int m_N, int storage_N>
matrix_solver_t *create_solver(int size, bool use_specific);
};

6
src/lib/netlist/solver/vector_base.h
View File

@ -14,17 +14,17 @@
#include "plib/pconfig.h"
#if 0
template <unsigned _storage_N>
template <unsigned storage_N>
struct pvector
{
pvector(unsigned size)
: m_N(size) { }
unsigned size() {
if (_storage_N)
if (storage_N)
}
double m_V[_storage_N];
double m_V[storage_N];
private:
unsigned m_N;
};