#include <boost/mpl/map.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/set.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/accumulate.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/erase_key.hpp>
#include "boost_mpl_string.h"


#define __NODE__(a) B4##a##Node


typedef enum {
__NODE__(d),
__NODE__(g),
__NODE__(s),
__NODE__(b),
__NODE__(gnd),
__NODE__(dp),
__NODE__(gp),
__NODE__(gp1),
__NODE__(sp),
__NODE__(bp),
__NODE__(bps),
__NODE__(bpd),
__NODE__(qn),
    TotalNodes
} BSIM4_PinNumbers ;

typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4gpNode>,
	boost::mpl::integral_c<long, B4spNode>
>::type VGS;
// base nlctrlv T_VBS (bp, sp)  { };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpNode>,
	boost::mpl::integral_c<long, B4spNode>
>::type VBS;
// base nlctrlv T_VDS (dp, sp) { };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4dpNode>,
	boost::mpl::integral_c<long, B4spNode>
>::type VDS;
// base nlctrlv T_VDDP (d, dp) { };    // for drain resistors
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4dNode>,
	boost::mpl::integral_c<long, B4dpNode>
>::type VDDP;
// base nlctrlv T_VSSP (s, sp) { };    // for source resistors
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4sNode>,
	boost::mpl::integral_c<long, B4spNode>
>::type VSSP;
// base nlctrlv T_VBPS (bps, sp) { };   // for source diode
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpsNode>,
	boost::mpl::integral_c<long, B4spNode>
>::type VBPS;
// base nlctrlv T_VBPD (bpd, dp) { };   // for drain diode
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpdNode>,
	boost::mpl::integral_c<long, B4dpNode>
>::type VBPD;
// base nlctrlv T_VGMGP (gp1, gp) { }; // for gate resistor when caps are moved
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4gp1Node>,
	boost::mpl::integral_c<long, B4gpNode>
>::type VGMG;
// base nlctrlv T_QDEF (qn,0)  { };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4qnNode>
>::type QDEF;


// base nlcs idp (dp, 0) { active_in_stab=1, control_ref = [ VGS, VBS, VDS, QDEF] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4dpNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, QDEF>::type,
	boost::mpl::bool_<true>
>::type IDP;
// base nlcs isp (sp, 0) { active_in_stab=1, control_ref = [ VGS,  VBS, VDS, QDEF] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, QDEF>::type,
	boost::mpl::bool_<true>
>::type ISP;
// base nlcs igp (gp, 0) { control_ref = [ VGS,  VBS, VDS, QDEF] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4gpNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, QDEF>::type,
	boost::mpl::bool_<true>
>::type IGP;
// base nlcs ibp (bp, 0) { control_ref = [ VGS,  VBS, VDS] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS>::type,
	boost::mpl::bool_<true>
>::type IBP;
//base nlcs ibps (bps, sp) { control_ref = [VBS, VBPS] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpsNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VBS, VBPS>::type,
	boost::mpl::bool_<true>
>::type IBPS;
// base nlcs ibpd (bpd, dp) { control_ref = [VBS,VDS, VBPD] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpdNode>,
		boost::mpl::integral_c<long, B4dpNode>
	>::type,
	boost::mpl::set<VBS, VDS, VBPD>::type,
	boost::mpl::bool_<true>
>::type IBPD;
// base nlcs isbias_dep (s, sp) { control_ref = [ VGS,  VBS,VSSP] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4sNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGS, VBS, VSSP>::type,
	boost::mpl::bool_<true>
>::type ISBIAS_DEP;
// base nlcs idbias_dep (d, dp) { control_ref = [ VGS,  VBS,VDS,VDDP] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4dNode>,
		boost::mpl::integral_c<long, B4dpNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, VDDP>::type,
	boost::mpl::bool_<true>
>::type IDBIAS_DEP;
// lumped g ig_eltd_g (g, gp1) { g=GATEvalue, addnoise = 0, hard_cut = HARD_CUT_RGATEMOD02 };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4gNode>,
	boost::mpl::integral_c<long, B4gp1Node>
>::type VGGP1;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4gNode>,
		boost::mpl::integral_c<long, B4gp1Node>
	>::type,
	boost::mpl::set<VGGP1>::type,
	boost::mpl::bool_<false>
>::type IG_ELTD_G;
// base nlcs ig_eltd (gp1, gp) { control_ref = [ VGS,  VBS, VDS, VGMG] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4gp1Node>,
		boost::mpl::integral_c<long, B4gpNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, VGMG>::type,
	boost::mpl::bool_<true>
>::type IG_ELTD;
// base nlqs qmid (gp1, sp) { control_ref = [ VGMG,VGS,VDS, VBS ] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4gp1Node>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGMG,VGS,VDS, VBS>::type,
	boost::mpl::bool_<true>
>::type QMID;
// lumped g RBPS (bp, bps) { g = GRBPSvalue, addnoise = OHMIC_NOISE, hard_cut = HARD_CUT_RSUBMOD };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpNode>,
	boost::mpl::integral_c<long, B4bpsNode>
>::type VBPBPS;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpNode>,
		boost::mpl::integral_c<long, B4bpsNode>
	>::type,
	boost::mpl::set<VBPBPS>::type,
	boost::mpl::bool_<false>
>::type RBPS;
// lumped g RBPD (bp, bpd) { g = GRBPDvalue, addnoise = OHMIC_NOISE, hard_cut = HARD_CUT_RSUBMOD };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpNode>,
	boost::mpl::integral_c<long, B4bpdNode>
>::type VBPBPD;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpNode>,
		boost::mpl::integral_c<long, B4bpdNode>
	>::type,
	boost::mpl::set<VBPBPD>::type,
	boost::mpl::bool_<false>
>::type RBPD;
// lumped g RBSB (bps, b) { g = GRBSBvalue, addnoise = OHMIC_NOISE };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpsNode>,
	boost::mpl::integral_c<long, B4bNode>
>::type VBPSB;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpsNode>,
		boost::mpl::integral_c<long, B4bNode>
	>::type,
	boost::mpl::set<VBPSB>::type,
	boost::mpl::bool_<false>
>::type RBSB;
// lumped g RBDB (bpd, b) { g = GRBDBvalue, addnoise = OHMIC_NOISE };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpdNode>,
	boost::mpl::integral_c<long, B4bNode>
>::type VBPDB;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpdNode>,
		boost::mpl::integral_c<long, B4bNode>
	>::type,
	boost::mpl::set<VBPDB>::type,
	boost::mpl::bool_<false>
>::type RBDB;
// lumped g RBPB (bp, b) { g = GRBPBvalue, addnoise = OHMIC_NOISE, hard_cut = HARD_CUT_RSUBMOD };
typedef boost::mpl::set<
	boost::mpl::integral_c<long, B4bpNode>,
	boost::mpl::integral_c<long, B4bNode>
>::type VBPB;
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpNode>,
		boost::mpl::integral_c<long, B4bNode>
	>::type,
	boost::mpl::set<VBPB>::type,
	boost::mpl::bool_<false>
>::type RBPB;
// 
// base nlqs qg (gp, sp) { control_ref = [ VGS,  VBS, VDS] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4gpNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS>::type,
	boost::mpl::bool_<true>
>::type QG;
// base nlqs qd (dp, sp) { control_ref = [ VGS,  VBS, VDS,VGMG] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4dpNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, VGMG>::type,
	boost::mpl::bool_<true>
>::type QD;
// base nlqs qb (bp, sp) { control_ref = [ VGS,  VBS, VDS,VGMG] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, VGMG>::type,
	boost::mpl::bool_<true>
>::type QB;
// base nlqs qbs (bps, sp) { control_ref = [ VBPS ] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpsNode>,
		boost::mpl::integral_c<long, B4spNode>
	>::type,
	boost::mpl::set<VBPS>::type,
	boost::mpl::bool_<true>
>::type QBS;
// base nlqs qbd (bpd, dp) { control_ref = [ VBPD ] };
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4bpdNode>,
		boost::mpl::integral_c<long, B4dpNode>
	>::type,
	boost::mpl::set<VBPD>::type,
	boost::mpl::bool_<true>
>::type QBD;
// lumped c cdum (qn,0) { c=CNQS} ;                          // for ddt(QDEF)
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4qnNode>
	>::type,
	boost::mpl::set<QDEF>::type,
	boost::mpl::bool_<false>
>::type CDUM;
// base nlqs qnqs (qn,0) { control_ref = [ VGS, VBS, VDS] }; // for -ddt(Qchn)
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4qnNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS>::type,
	boost::mpl::bool_<true>
>::type QNQS;
// base nlcs rnqs (qn,0) {control_ref=[ VGS, VBS, VDS, QDEF] }; // for QDEF/TAU
typedef boost::mpl::vector<
	boost::mpl::set<
		boost::mpl::integral_c<long, B4qnNode>
	>::type,
	boost::mpl::set<VGS, VBS, VDS, QDEF>::type,
	boost::mpl::bool_<true>
>::type RNQS;
typedef boost::mpl::set<
	IDP, ISP, IGP, IBP, IBPS, IBPD, ISBIAS_DEP, IDBIAS_DEP, IG_ELTD_G, IG_ELTD, RBPS, RBPD, RBSB, RBDB, RBPB, RNQS
>::type NONLINEAR_CURRENTS;
typedef boost::mpl::set<
	QMID, QG, QD, QB, QBS, QBD, CDUM, QNQS
>::type NONLINEAR_CHARGES;


template<typename __PAIR__>
struct CGetSecond
{	typedef typename __PAIR__::second type;
};

template<typename __PAIR__>
struct CGetFirst
{	typedef typename __PAIR__::first type;
};



template<typename __MAP__>
struct CConvertIntoArray
{	typedef typename boost::mpl::accumulate<
		__MAP__,
		typename boost::mpl::vector<>::type,
		typename boost::mpl::lambda<
			boost::mpl::push_back<
				boost::mpl::_1,
				boost::mpl::_2
			>
		>::type
	>::type type;		
};


// creates a map of index to bool=false
template<typename __NUMBER_OF_NODES__>
struct CCreateBoolVector
{	typedef typename boost::mpl::accumulate<
		typename boost::mpl::range_c<
			long, 
			0, 
			__NUMBER_OF_NODES__::value
		>::type,
		typename boost::mpl::map<>::type,
		typename boost::mpl::lambda<
			boost::mpl::insert<
				boost::mpl::_1,
				boost::mpl::pair<
					boost::mpl::_2,
					boost::mpl::bool_<false>
				>
			>
		>::type
	>::type type;
};


// sets the entry for the node voltage to true
template<typename __VOLTAGE__, typename __BV__>
struct CForeachVoltage
{	typedef typename boost::mpl::accumulate<
		__VOLTAGE__,
		__BV__,
		typename boost::mpl::lambda<
			boost::mpl::insert<
				boost::mpl::_1,
				boost::mpl::pair<
					boost::mpl::_2,
					boost::mpl::bool_<true>
				>
			>
		>::type
	>::type type;
};


// iterates over all the controls and sets the bool entries to true for the matching node voltage
template<typename __SOURCE__, typename __NUMBER_OF_NODES__>
struct CForeachControl
{	typedef typename boost::mpl::accumulate<
		typename boost::mpl::at<__SOURCE__, boost::mpl::integral_c<long, 1> >::type,
		typename CCreateBoolVector<__NUMBER_OF_NODES__>::type,
		typename boost::mpl::lambda<
			CForeachVoltage<boost::mpl::_2, boost::mpl::_1>
		>::type
	>::type type;
};


// two dimensional set
template<typename __IX__, typename __IY__, typename __MATRIX__, typename __E__, typename __NUMBER_OF_NODES__>
struct CInsert2
{	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<__MATRIX__> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<__MATRIX__>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::insert<
		typename boost::mpl::erase_key<
			__MATRIX__,
			__IX__
		>::type,
		boost::mpl::pair<
			__IX__,
			typename boost::mpl::insert<
				typename boost::mpl::erase_key<
					typename boost::mpl::at<
						__MATRIX__,
						__IX__
					>::type,
					__IY__
				>::type,
				boost::mpl::pair<
					__IY__,
					__E__
				>
			>::type
		>
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
};


// set characters in two dimensional matrix
template<typename __NODE__, typename __SOURCE__, typename __MAP__, typename __NUMBER_OF_NODES__, typename __I__>
struct CReplaceMatrix
{	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<__MAP__> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<__MAP__>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::at<
		__MAP__,
		__NODE__
	>::type CNodeMap;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<CNodeMap> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<CNodeMap>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::if_<
		typename boost::mpl::at<
			typename CForeachControl<__SOURCE__, __NUMBER_OF_NODES__>::type,
			__I__
		>::type,
		typename boost::mpl::if_<
			typename boost::mpl::at<__SOURCE__, boost::mpl::integral_c<long, 2> >::type,
			typename CInsert2<__NODE__, __I__, __MAP__, boost::mpl::char_<'2'>, __NUMBER_OF_NODES__>::type,
			typename boost::mpl::if_<
				typename boost::mpl::equal_to<
					typename boost::mpl::at<
						CNodeMap,
						__I__
					>::type,
					boost::mpl::char_<'2'>
				>::type,
				__MAP__,
				typename CInsert2<
					__NODE__,
					__I__,
					__MAP__,
					boost::mpl::char_<'1'>,
					__NUMBER_OF_NODES__
				>::type
			>::type
		>::type,
		__MAP__
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
};


template<typename __NUMBER_OF_NODES__>
struct CCreateEmptyString
{	typedef typename boost::mpl::accumulate<
		typename boost::mpl::range_c<
			long, 
			0, 
			__NUMBER_OF_NODES__::value
		>::type,
		typename boost::mpl::map<>::type,
		typename boost::mpl::lambda<
			boost::mpl::insert<
				boost::mpl::_1,
				boost::mpl::pair<
					boost::mpl::_2,
					boost::mpl::char_<'.'>
				>
			>
		>::type
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
};

template<typename __PAIR__, typename __NUMBER_OF_NODES__>
struct CCheckSubMap
{	typedef typename __PAIR__::second second;
	typedef __PAIR__ type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<second> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<second>,
		__NUMBER_OF_NODES__
	>));
};

template<typename __MAP__, typename __NUMBER_OF_NODES__>
struct CCheckSubMaps
{	typedef typename boost::mpl::accumulate<
		__MAP__,
		boost::mpl::map<>,
		typename boost::mpl::lambda<
			boost::mpl::insert<
				boost::mpl::_1,
				CCheckSubMap<boost::mpl::_2, __NUMBER_OF_NODES__>
			>
		>::type
	>::type type;
};

template<typename __NUMBER_OF_NODES__>
struct CCreateMap
{	typedef typename CCreateEmptyString<__NUMBER_OF_NODES__>::type item;
	typedef typename boost::mpl::accumulate<
		typename boost::mpl::range_c<
			long, 
			0, 
			__NUMBER_OF_NODES__::value
		>::type,
		typename boost::mpl::map<>::type,
		typename boost::mpl::lambda<
			boost::mpl::insert<
				boost::mpl::_1,
				boost::mpl::pair<
					boost::mpl::_2,
					item
				>
			>
		>::type
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::at<
		type,
		boost::mpl::integral_c<long, 0>
	>::type CNodeMap;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<CNodeMap> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<CNodeMap>,
		__NUMBER_OF_NODES__
	>));
/*
	typedef typename CCheckSubMaps<type, __NUMBER_OF_NODES__>::type check;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<check> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<check>,
		__NUMBER_OF_NODES__
	>));
*/
};



template<typename __NODE__, typename __SOURCE__, typename __MAP__, typename __NUMBER_OF_NODES__>
struct CForThisNode
{	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<__MAP__> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<__MAP__>,
		__NUMBER_OF_NODES__
	>));
/*
			void operator()(boost::mpl::integral_c<long, __NODE__>)
			{	for (size_t i = 0; i < __NUMBER_OF_NODES__; ++i)
					if (m_rV[i])
						if (m_bNL)
							(*m_pap)[__NODE__][i] = '2';
						else
							if ((*m_pap)[__NODE__][i] == '2')
								;
							else
								(*m_pap)[__NODE__][i] = '1';
			}
*/
	typedef typename boost::mpl::at<
		__MAP__,
		__NODE__
	>::type CNodeMap;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<CNodeMap> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<CNodeMap>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::accumulate<
		typename boost::mpl::range_c<
			long, 
			0, 
			__NUMBER_OF_NODES__::value
		>::type,
		__MAP__,
		typename boost::mpl::lambda<
			CReplaceMatrix<__NODE__, __SOURCE__, boost::mpl::_1, __NUMBER_OF_NODES__, boost::mpl::_2>
		>::type			
	>::type type;						
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::at<
		type,
		__NODE__
	>::type CNodeMap1;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<CNodeMap1> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<CNodeMap1>,
		__NUMBER_OF_NODES__
	>));
};

template<typename __SOURCE__, typename __NUMBER_OF_NODES__, typename __MAP__>
struct CForOneSource
{	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<__MAP__> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<__MAP__>,
		__NUMBER_OF_NODES__
	>));
	typedef typename boost::mpl::accumulate<
			// for every node
		typename boost::mpl::at<__SOURCE__, boost::mpl::integral_c<long, 0> >::type,
		__MAP__,
		typename boost::mpl::lambda<
			CForThisNode<
				boost::mpl::_2, // node
				__SOURCE__,
				boost::mpl::_1, // map
				//typename boost::mpl::at<__SOURCE__, typename boost::mpl::integral_c<long, 2> >,
				__NUMBER_OF_NODES__
			>
		>::type
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
	BOOST_MPL_ASSERT(( boost::mpl::equal<
		boost::mpl::size<type>,
		__NUMBER_OF_NODES__
	>));
};

template<typename __NL__, typename __NUMBER_OF_NODES__>
struct CForAllSources
{	typedef typename boost::mpl::accumulate<
		__NL__,
		typename CCreateMap<__NUMBER_OF_NODES__>::type,
		typename boost::mpl::lambda<
			CForOneSource<boost::mpl::_2, __NUMBER_OF_NODES__, boost::mpl::_1>
		>::type
	>::type type;
	BOOST_MPL_ASSERT(( boost::mpl::is_sequence<type> ));
};

template<typename C, typename I>
struct push_back_second
{	typedef typename boost::mpl::push_back<C, typename I::type::second>::type type;
};
template<typename __MAP__>
struct CConvertIntoString
{	typedef typename boost::mpl::accumulate<
		__MAP__,
		boost::mpl::string<>,
		typename boost::mpl::lambda<
			boost::mpl::push_back<
				boost::mpl::_1,
				CGetSecond<boost::mpl::_2>
			>
		>::type
	>::type type;
};
                                    //0123456789abc

template<typename __MAP__, typename __NUMBER_OF_NODES__>
struct CCreateArray
{	static const char *ap[__NUMBER_OF_NODES__::value];
	struct CForeach
	{	template<typename T>
		void operator()(T)
		{	ap[T::first::value] = CConvertIntoString<typename T::second>::type::c_str;
		}
	};
	const char *const *operator()(void) const
	{	if (!ap[0])
			boost::mpl::for_each<__MAP__>(CForeach());
		return ap;
	}
};

typedef CCreateArray<
	CForAllSources<
		NONLINEAR_CURRENTS, 
		boost::mpl::integral_c<long, TotalNodes>
	>::type,
	boost::mpl::integral_c<long, TotalNodes>
>::type_info CCurrents;
typedef CCreateArray<
	CForAllSources<
		NONLINEAR_CHARGES, 
		boost::mpl::integral_c<long, TotalNodes>
	>::type,
	boost::mpl::integral_c<long, TotalNodes>
>::type_info CCharges;


const char *CCurrents::ap[];
const char *CCharges::ap[];


static const char *const *const s_apCurrents = CCurrents()();
static const char *const *const s_apCharges = CCharges()();

#include <iostream>

int main(int argc, char **argv)
{	for (const char *const *p = s_apCurrents; p != s_apCurrents + TotalNodes; ++p)
		std::cout << *p << std::endl;
	return 0;
}