ndxl 1.0.0__tar.gz

ndxl-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: ndxl
+Version: 1.0.0
+Summary: Network Dynamics eXperimentation Library
+Author: Ethan Codron
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

ndxl-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ndxl"
+version = "1.0.0"
+description = "Network Dynamics eXperimentation Library"
+authors = [
+    {name = "Ethan Codron"}
+]
+readme = "README.md"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+package-dir = {""="src"}
+
+[tool.setuptools.packages.find]
+where=["src"]
+
+[tool.setuptools.package-data]
+ndxl=["lib/*.dll","lib/*.so"]

ndxl-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ndxl-1.0.0/src/ndxl/__init__.py

@@ -0,0 +1,6 @@
+from .core import *
+from .edge import *
+from .network import *
+from .vertex import *
+
+lib.ndxlInit()

ndxl-1.0.0/src/ndxl/core.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Union
+
+import copy
+import ctypes
+import inspect
+import numpy as np
+import platform
+
+# Load library from relative path
+_cwd = Path(__file__).resolve().parent
+libname = "NDXL.dll" if platform.system() == "Windows" else "libNDXL.so"
+lib = ctypes.CDLL(str(_cwd / "lib" / libname))
+
+
+# Error definitions from library header
+NDXL_OK		 	= 0
+NDXL_ERR		= -1
+NDXL_VALUE_ERR  = 1
+NDXL_TYPE_ERR   = 2
+NDXL_ARG_ERR	= 3
+
+
+# NDXL object definitions
+class NDXLNetwork(ctypes.Structure): pass
+NDXLNetwork_p = ctypes.POINTER(NDXLNetwork)
+
+class NDXLVertex(ctypes.Structure): pass
+NDXLVertex_p = ctypes.POINTER(NDXLVertex)
+
+class NDXLEdge(ctypes.Structure): pass
+NDXLEdge_p = ctypes.POINTER(NDXLEdge)
+
+
+# NDXL core functions
+lib.ndxlGetLastErrorCode.restype = ctypes.c_int
+lib.ndxlGetLastErrorCode.argtypes = []
+
+lib.ndxlGetLastErrorMsg.restype = ctypes.c_char_p
+lib.ndxlGetLastErrorMsg.argtypes = []
+
+lib.ndxlPrintError.restype = None
+lib.ndxlPrintError.argtypes = []
+
+lib.ndxlRaiseError.restype = None
+lib.ndxlRaiseError.argtypes = [ctypes.c_int, ctypes.c_char_p]
+
+lib.ndxlInit.restype = ctypes.c_int
+lib.ndxlInit.argtypes = []
+
+
+# Wrapper functions
+def libinit():
+	return lib.ndxlInit()
+
+def get_last_error_code():
+	return lib.ndxlGetLastErrorCode()
+
+def get_last_error_msg():
+	return lib.ndxlGetLastErrorMsg().value.decode('utf-8')
+
+def print_error():
+	lib.ndxlPrintError()
+
+def raise_error(code, msg):
+	lib.ndxlRaiseError(code, ctypes.c_char_p(msg.encode('utf-8')))

ndxl-1.0.0/src/ndxl/edge.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from .core import *
+
+# Callbacks vvvvv
+
+NDXLEdgeFunction = ctypes.CFUNCTYPE(None, NDXLEdge_p, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_void_p)
+NDXLEdgeCallback = ctypes.CFUNCTYPE(None, NDXLEdge_p, ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_void_p)
+NoneEFn = NDXLEdgeFunction(0)
+NoneECb = NDXLEdgeCallback(0)
+
+# ^^^^^ Callbacks | constructor and destructor vvvvv
+
+lib.ndxlCreateEdge.restype = NDXLEdge_p
+lib.ndxlCreateEdge.argtypes = [NDXLVertex_p, NDXLVertex_p, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, ctypes.c_double, ctypes.c_bool, NDXLEdgeFunction, NDXLEdgeFunction, NDXLEdgeCallback, ctypes.c_void_p]
+
+lib.ndxlCopyEdge.restype = NDXLEdge_p
+lib.ndxlCopyEdge.argtypes = [NDXLEdge_p, NDXLVertex_p, NDXLVertex_p, ctypes.c_bool, ctypes.c_bool, ctypes.c_void_p]
+
+lib.ndxlDestroyEdge.restype = ctypes.c_int
+lib.ndxlDestroyEdge.argtypes = [ctypes.POINTER(NDXLEdge_p)]
+
+# ^^^^^ Constructor and destructor | getters vvvvv
+
+lib.ndxlGetEdgeCallback.restype = NDXLEdgeCallback
+lib.ndxlGetEdgeCallback.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetEdgeDelay.restype = ctypes.c_double
+lib.ndxlGetEdgeDelay.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeFirstVertex.restype = NDXLVertex_p
+lib.ndxlGetEdgeFirstVertex.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeFunction.restype = NDXLEdgeFunction
+lib.ndxlGetEdgeFunction.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetEdgeInitialState.restype = ctypes.POINTER(ctypes.c_double)
+lib.ndxlGetEdgeInitialState.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeNoise.restype = NDXLEdgeFunction
+lib.ndxlGetEdgeNoise.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetEdgeOrder.restype = ctypes.c_size_t
+lib.ndxlGetEdgeOrder.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeParams.restype = ctypes.c_void_p
+lib.ndxlGetEdgeParams.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeParent.restype = NDXLNetwork_p
+lib.ndxlGetEdgeParent.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeSecondVertex.restype = NDXLVertex_p
+lib.ndxlGetEdgeSecondVertex.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeState.restype = ctypes.POINTER(ctypes.c_double)
+lib.ndxlGetEdgeState.argtypes = [NDXLEdge_p]
+
+lib.ndxlGetEdgeTime.restype = ctypes.c_double
+lib.ndxlGetEdgeTime.argtypes = [NDXLEdge_p]
+
+# ^^^^^ Getters | setters vvvvv
+
+lib.ndxlSetEdgeCallback.restype = ctypes.c_int
+lib.ndxlSetEdgeCallback.argtypes = [NDXLVertex_p, NDXLEdgeCallback]
+
+lib.ndxlSetEdgeFunction.restype = ctypes.c_int
+lib.ndxlSetEdgeFunction.argtypes = [NDXLVertex_p, NDXLEdgeFunction]
+
+lib.ndxlSetEdgeNoise.restype = ctypes.c_int
+lib.ndxlSetEdgeNoise.argtypes = [NDXLVertex_p, NDXLEdgeFunction]
+
+lib.ndxlSetEdgeState.restype = ctypes.c_int
+lib.ndxlSetEdgeState.argtypes = [NDXLEdge_p, ctypes.POINTER(ctypes.c_double)]
+
+# ^^^^^ Setters | functions vvvvv
+
+lib.ndxlEdgeContainsVertex.restype = ctypes.c_bool
+lib.ndxlEdgeContainsVertex.argtypes = [NDXLEdge_p, NDXLVertex_p]
+
+lib.ndxlEdgeReset.restype = ctypes.c_int
+lib.ndxlEdgeReset.argtypes = [NDXLEdge_p]
+
+# ^^^^^ Functions | Python wrappers vvvvv
+
+class edge:
+	def __init__(self, ptr, args):
+		self._ptr = ptr
+		self._pptr = args
+		self._params = ctypes.cast(self._pptr, ctypes.POINTER(ctypes.py_object)).contents.value
+		self._cplx = self._params[-3]
+
+	def __del__(self):
+		self._ptr = None
+		self._pptr = None
+		self._params = None
+
+	def __bool__(self):
+		return self._ptr != 0
+
+	def __len__(self):
+		_ord = lib.ndxlGetEdgeOrder(self._ptr)
+		return (_ord // 2) if self._cplx else _ord
+
+	def __str__(self):
+		return "'<ndxl.edge object at " + f"{id(self._ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}" + " {'parent': " + f"<ndxl.network object at {id(self.parent.c_ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}>" + ", 'vertex 1': " + str(self.first_vertex) + ", 'vertex 2': " + str(self.second_vertex) + ", 'state': " + str(self.state) + ", 'initial-state': " + str(self.initial_state) + ", 'time': " + str(lib.ndxlGetEdgeTime(self._ptr)) + ", 'function': " + str(self._params[0]) + ", 'noise': " + str(self._params[1]) + ", 'callback': " + str(self._params[2]) + "}>'"
+
+	def __repr__(self):
+		return f"NDXL edge\n===========\n\nParent: <ndxl.network object at {id(self.parent.c_ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}>\nVertex 1: {self.first_vertex}\nVertex 2: {self.second_vertex}\nState: {self.state}\nInitial state: {self.initial_state}\nFunction: {self._params[0]}\nNoise: {self._params[1]}\nCallback: {self._params[2]}\nTime: {lib.ndxlGetEdgeTime(self._ptr)}\n"
+
+	@property
+	def c_ptr(self):
+		return self._ptr
+
+	def destroy(self):
+		_res = lib.ndxlDestroyEdge(ctypes.pointer(self._ptr))
+		del self._pptr
+		del self._params
+		return _res
+
+	@property
+	def callback(self):
+		return lib.ndxlGetEdgeCallback(self._ptr)
+
+	@callback.setter
+	def callback(self, cb):
+		self._params[2] = cb
+		return lib.ndxlSetEdgeCallback(self._ptr, NoneECb if cb is None else _ecb_bridge)
+
+	@property
+	def cplx(self):
+		return self._cplx
+
+	@property
+	def delay(self):
+		return lib.ndxlGetEdgeDelay(self._ptr)
+
+	@property
+	def first_vertex(self):
+		from .vertex import vertex
+		_vert = lib.ndxlGetEdgeFirstVertex(self._ptr)
+		return vertex(_vert, lib.ndxlGetVertexParams(_vert))
+
+	@property
+	def func(self):
+		return lib.ndxlGetEdgeFunction(self._ptr)
+
+	@func.setter
+	def func(self, fn):
+		self._params[0] = fn
+		return lib.ndxlSetEdgeFunction(self._ptr, NoneEFn if fn is None else _efunc_bridge)
+
+	@property
+	def initial_state(self):
+		return lib.ndxlGetEdgeInitialState(self._ptr)[:lib.ndxlGetEdgeOrder(self._ptr)]
+
+	@property
+	def noise(self):
+		return lib.ndxlGetEdgeNoise(self._ptr)
+
+	@noise.setter
+	def noise(self, zeta):
+		self._params[1] = zeta
+		return lib.ndxlSetEdgeNoise(self._ptr, NoneEFn if zeta is None else _enoise_bridge)
+
+	@property
+	def order(self):
+		return lib.ndxlGetEdgeOrder(self._ptr)
+
+	@property
+	def parent(self):
+		from .network import network
+		_nwk = lib.ndxlGetEdgeParent(self._ptr)
+		return network(_nwk, lib.ndxlGetNetworkParams(_nwk))
+
+	@property
+	def second_vertex(self):
+		from .vertex import vertex
+		_vert = lib.ndxlGetEdgeSecondVertex(self._ptr)
+		return vertex(_vert, lib.ndxlGetVertexParams(_vert))
+
+	@property
+	def shape(self):
+		return self._params[-2]
+
+	@property
+	def state(self):
+		_ord = self.order
+		_state = np.ctypeslib.as_array(lib.ndxlGetEdgeState(self._ptr), shape=(_ord,))
+		if self._cplx:
+			return (_state[:_ord // 2] + 1j * _state[_ord // 2: _ord]).reshape(self._params[-2])
+		return _state.reshape(self._params[-2])
+
+	@state.setter
+	def state(self, st):
+		_state = None
+		_nstate = 0
+		if st is not None:
+			_arr = np.asarray(st)
+			if self._cplx:
+				_ord = lib.ndxlGetEdgeOrder(self._ptr) // 2
+				_st = np.asarray(_arr.flatten(), dtype=complex)
+				_nstate = len(_st)
+				if _nstate != _ord:
+					raise ValueError(f"Attempting to assign {_nstate}-element state vector to edge of order {_ord}.")
+				_state = np.ctypeslib.as_ctypes(np.append(_st.real, _st.imag))
+			else:
+				_ord = lib.ndxlGetEdgeOrder(self._ptr)
+				_st = np.asarray(_arr.flatten(), dtype=float)
+				_nstate = len(_st)
+				if _nstate != _ord:
+					raise ValueError(f"Attempting to assign {_nstate}-element state vector to edge of order {_ord}.")
+				_state = np.ctypeslib.as_ctypes(_st)
+		return lib.ndxlSetEdgeState(self._ptr, _state)
+
+	@property
+	def time(self):
+		return lib.ndxlGetEdgeTime(self._ptr)
+
+@NDXLEdgeFunction
+def _efunc_bridge(ed, dstate, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_func = _meta[0]
+	if _func:
+		_userdata = _meta[-1]
+		_e = edge(ed, lib.ndxlGetEdgeParams(ed))
+		_ord = _e.order
+		_inview = np.ctypeslib.as_array(state, shape=(_ord,))
+		_outview = np.ctypeslib.as_array(dstate, shape=(_ord,))
+		if _e.cplx:
+			_len = len(_e)
+			_result = np.asarray(_func(_e, (_inview[:_len] + 1j * _inview[_len: _ord]).reshape(_e.shape), time, *_userdata)).flatten()
+			_outview[:] = np.append(_result.real, _result.imag)
+		else:
+			_outview[:] = np.asarray(_func(_e, _inview.reshape(_e.shape), time, *_userdata)).flatten()
+
+@NDXLEdgeFunction
+def _enoise_bridge(ed, dstate, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_noise = _meta[1]
+	if _noise:
+		_userdata = _meta[-1]
+		_e = edge(ed, lib.ndxlGetEdgeParams(ed))
+		_ord = _e.order
+		_inview = np.ctypeslib.as_array(state, shape=(_ord,))
+		_outview = np.ctypeslib.as_array(dstate, shape=(_ord,))
+		if _e.cplx:
+			_len = len(_e)
+			_result = np.asarray(_noise(_e, (_inview[:_len] + 1j * _inview[_len: _ord]).reshape(_e.shape), time, *_userdata)).flatten()
+			_outview[:] = np.append(_result.real, _result.imag)
+		else:
+			_outview[:] = np.asarray(_noise(_e, _inview.reshape(_e.shape), time, *_userdata)).flatten()
+
+@NDXLEdgeCallback
+def _ecb_bridge(ed, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_cb = _meta[2]
+	if _cb:
+		_userdata = _meta[-1]
+		_e = edge(ed, lib.ndxlGetEdgeParams(ed))
+		_ord = _e.order
+		_view = np.ctypeslib.as_array(state, shape=(_ord,))
+		if _e.cplx:
+			_len = len(_e)
+			_tview = (_view[:_len] + 1j * _view[_len: _ord]).reshape(_e.shape)
+			_cb(_e, _tview, time, *_userdata)
+			_tview = _tview.flatten()
+			_view[:] = np.append(_tview.real, _tview.imag)
+		else:
+			_cb(_e, _view.reshape(_v.shape), time, *_userdata)
+
+# ^^^^^ Python wrappers

ndxl-1.0.0/src/ndxl/network.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from .core import *
+
+# Callbacks vvvvv
+
+NDXLNetworkCallback = ctypes.CFUNCTYPE(None, NDXLNetwork_p, ctypes.c_double, ctypes.c_void_p)
+
+# ^^^^^ Callbacks | constructor and destructor vvvvv
+
+lib.ndxlCreateNetwork.restype = NDXLNetwork_p
+lib.ndxlCreateNetwork.argtypes = [ctypes.c_void_p]
+
+lib.ndxlDestroyNetwork.restype = ctypes.c_int
+lib.ndxlDestroyNetwork.argtypes = [ctypes.POINTER(NDXLNetwork_p)]
+
+# ^^^^^ Constructor and destructor | getters vvvvv
+
+lib.ndxlGetNetworkEdges.restype = ctypes.c_int
+lib.ndxlGetNetworkEdges.argtypes = [NDXLNetwork_p, ctypes.POINTER(NDXLEdge_p)]
+
+lib.ndxlGetNetworkOrder.restype = ctypes.c_size_t
+lib.ndxlGetNetworkOrder.argtypes = [NDXLNetwork_p]
+
+lib.ndxlGetNetworkParams.restype = ctypes.c_void_p
+lib.ndxlGetNetworkParams.argtypes = [NDXLNetwork_p]
+
+lib.ndxlGetNetworkSize.restype = ctypes.c_size_t
+lib.ndxlGetNetworkSize.argtypes = [NDXLNetwork_p]
+
+lib.ndxlGetNetworkTime.restype = ctypes.c_double
+lib.ndxlGetNetworkTime.argtypes = [NDXLNetwork_p]
+
+lib.ndxlGetNetworkVertices.restype = ctypes.c_int
+lib.ndxlGetNetworkVertices.argtypes = [NDXLNetwork_p, ctypes.POINTER(NDXLVertex_p)]
+
+# ^^^^^ Getters | functions vvvvv
+
+lib.ndxlNetworkReset.restype = ctypes.c_int
+lib.ndxlNetworkReset.argtypes = [NDXLNetwork_p]
+
+lib.ndxlNetworkSimulateRalston.restype = ctypes.c_int
+lib.ndxlNetworkSimulateRalston.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, NDXLNetworkCallback]
+
+lib.ndxlNetworkSimulateNystrom.restype = ctypes.c_int
+lib.ndxlNetworkSimulateNystrom.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, NDXLNetworkCallback]
+
+lib.ndxlNetworkSimulateDopri.restype = ctypes.c_int
+lib.ndxlNetworkSimulateDopri.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, NDXLNetworkCallback]
+
+lib.ndxlNetworkSimulateRkck.restype = ctypes.c_int
+lib.ndxlNetworkSimulateRkck.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, NDXLNetworkCallback]
+
+lib.ndxlNetworkSimulateNorsett.restype = ctypes.c_int
+lib.ndxlNetworkSimulateNorsett.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, NDXLNetworkCallback]
+
+lib.ndxlNetworkSimulateRadau.restype = ctypes.c_int
+lib.ndxlNetworkSimulateRadau.argtypes = [NDXLNetwork_p, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, NDXLNetworkCallback]
+
+# ^^^^^ Functions | Python wrappers vvvvv
+
+class network:
+	def __init__(self, ptr, args):
+		self._ptr = ptr
+		self._pptr = args
+		self._params = ctypes.cast(self._pptr, ctypes.POINTER(ctypes.py_object)).contents.value
+
+	def __del__(self):
+		self._ptr = None
+		self._pptr = None
+		self._params = None
+
+	def __bool__(self):
+		return self._ptr != 0
+
+	def __str__(self):
+		return "'<ndxl.network object at " + f"{id(self._ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}" + " {'order': " + str(lib.ndxlGetNetworkOrder(self._ptr)) + ", 'size': " + str(lib.ndxlGetNetworkSize(self._ptr)) + ", 'time': " + str(lib.ndxlGetNetworkTime(self._ptr)) + "}>'"
+
+	def __repr__(self):
+		return f"NDXL network\n============\n\nVertices (order): {lib.ndxlGetNetworkOrder(self._ptr)}\nEdges (size): {lib.ndxlGetNetworkSize(self._ptr)}\nTime: {lib.ndxlGetNetworkTime(self._ptr)}\n"
+
+	@property
+	def c_ptr(self):
+		return self._ptr
+
+	def destroy(self):
+		_res = lib.ndxlDestroyNetwork(ctypes.pointer(self._ptr))
+		del self._pptr
+		del self._params
+		return _res
+
+	@property
+	def edges(self):
+		from .edge import edge
+		_ne = lib.ndxlGetNetworkSize(self._ptr)
+		_arr = (NDXLEdge_p * _ne)()
+		lib.ndxlGetNetworkEdges(self._ptr, _arr)
+		return [edge(_arr[i], lib.ndxlGetEdgeParams(_arr[i])) for i in range(_ne)]
+
+	@property
+	def order(self):
+		return lib.ndxlGetNetworkOrder(self._ptr)
+
+	@property
+	def size(self):
+		return lib.ndxlGetNetworkSize(self._ptr)
+
+	@property
+	def time(self):
+		return lib.ndxlGetNetworkTime(self._ptr)
+
+	@property
+	def vertices(self):
+		from .vertex import vertex
+		_nv = lib.ndxlGetNetworkOrder(self._ptr)
+		_arr = (NDXLVertex_p * _nv)()
+		lib.ndxlGetNetworkVertices(self._ptr, _arr)
+		return [vertex(_arr[i], lib.ndxlGetVertexParams(_arr[i])) for i in range(_nv)]
+
+	def reset(self):
+		return lib.ndxlNetworkReset(self._ptr)
+
+	def simulate_ralston(self, tspan, step=0.1, cb=None):
+		self._params[0] = cb
+		return lib.ndxlNetworkSimulateRalston(self._ptr, tspan, step, _network_bridge)
+
+	def simulate_nystrom(self, tspan, step=0.1, cb=None):
+		self._params[0] = cb
+		return lib.ndxlNetworkSimulateNystrom(self._ptr, tspan, step, _network_bridge)
+
+	def simulate_dopri(self, tspan, atol=1e-6, rtol=1e-3, tstops=None, cb=None):
+		self._params[0] = cb
+		_nstops = 0 if tstops is None else len(tstops)
+		_tstops = None if tstops is None else (ctypes.c_double * _nstops)(*tstops)
+		return lib.ndxlNetworkSimulateDopri(self._ptr, tspan, atol, rtol, _tstops, _nstops, _network_bridge)
+
+	def simulate_rkck(self, tspan, atol=1e-6, rtol=1e-3, tstops=None, cb=None):
+		self._params[0] = cb
+		_nstops = 0 if tstops is None else len(tstops)
+		_tstops = None if tstops is None else (ctypes.c_double * _nstops)(*tstops)
+		return lib.ndxlNetworkSimulateRkck(self._ptr, tspan, atol, rtol, _tstops, _nstops, _network_bridge)
+
+	def simulate_nystrom(self, tspan, step=0.1, cb=None):
+		raise NotImplementedError("This function is under construction and will be available soon!")
+		#self._params[0] = cb
+		#return lib.ndxlNetworkSimulateNorsett(self._ptr, tspan, step, _network_bridge)
+
+	def simulate_radau(self, tspan, atol=1e-10, rtol=1e-8, tstops=None, cb=None):
+		raise NotImplementedError("This function is under construction and will be available soon!")
+		#self._params[0] = cb
+		#_nstops = 0 if tstops is None else len(tstops)
+		#_tstops = None if tstops is None else (ctypes.c_double * _nstops)(*tstops)
+		#return lib.ndxlNetworkSimulateRadau(self._ptr, tspan, atol, rtol, _tstops, _nstops, _network_bridge)
+
+	def create_vertex(self, state=None, func=None, noise=None, cb=None, args=None, cplx=False):
+		from .vertex import vertex, _vfunc_bridge, _vnoise_bridge, _vcb_bridge, NoneVFn, NoneVCb
+		_state = None
+		_nstate = 0
+		_sstate = ()
+		_cplx = cplx
+		if state is not None:
+			_arr = np.asarray(state)
+			_sstate = _arr.shape
+			if _arr.dtype == complex:
+				_st = np.asarray(_arr.flatten(), dtype=complex)
+				_nstate = len(_st) * 2
+				_state = np.ctypeslib.as_ctypes(np.append(_st.real, _st.imag))
+				_cplx = True
+			else:
+				_st = np.asarray(_arr.flatten(), dtype=float)
+				_nstate = len(_st)
+				_state = np.ctypeslib.as_ctypes(_st)
+		_pptr = ctypes.cast(ctypes.pointer(ctypes.py_object([func, noise, cb, _cplx, _sstate, () if args is None else copy.deepcopy(args)])), ctypes.c_void_p)
+		return vertex(lib.ndxlCreateVertex(self._ptr, _state, _nstate, NoneVFn if func is None else _vfunc_bridge, NoneVFn if noise is None else _vnoise_bridge, NoneVCb if cb is None else _vcb_bridge, _pptr), _pptr)
+
+	def create_edge(self, v1, v2, state=None, delay=0., directed=False, func=None, noise=None, cb=None, args=None):
+		from .edge import edge, _efunc_bridge, _enoise_bridge, _ecb_bridge, NoneEFn, NoneECb
+		_state = None
+		_nstate = 0
+		_sstate = ()
+		_cplx = cplx
+		if state is not None:
+			_arr = np.asarray(state)
+			_sstate = _arr.shape
+			if _arr.dtype == complex:
+				_st = np.asarray(_arr.flatten(), dtype=complex)
+				_nstate = len(_st) * 2
+				_state = np.ctypeslib.as_ctypes(np.append(_st.real, _st.imag))
+				_cplx = True
+			else:
+				_st = np.asarray(_arr.flatten(), dtype=float)
+				_nstate = len(_st)
+				_state = np.ctypeslib.as_ctypes(_st)
+		_pptr = ctypes.cast(ctypes.pointer(ctypes.py_object([func, noise, cb, _cplx, _sstate, () if args is None else copy.deepcopy(args)])), ctypes.c_void_p)
+		return edge(lib.ndxlCreateEdge(v1 if isinstance(v1, NDXLVertex_p) else v1.c_ptr, v2 if isinstance(v2, NDXLVertex_p) else v2.c_ptr, _state, _nstate, delay, directed, NoneEFn if func is None else _efunc_bridge, NoneEFn if noise is None else _enoise_bridge, NoneECb if cb is None else _ecb_bridge, _pptr), _pptr)
+
+def create_network(args=None):
+	_pptr = ctypes.cast(ctypes.pointer(ctypes.py_object([None, () if args is None else copy.deepcopy(args)])), ctypes.c_void_p)
+	return network(lib.ndxlCreateNetwork(_pptr), _pptr)
+
+@NDXLNetworkCallback
+def _network_bridge(nwk, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_cb = _meta[0]
+	if _cb:
+		_userdata = _meta[1]
+		_cb(network(nwk, lib.ndxlGetNetworkParams(nwk)), time, *_userdata)
+
+# ^^^^^ Python wrappers

ndxl-1.0.0/src/ndxl/vertex.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+from .core import *
+
+# Callbacks vvvvv
+
+NDXLVertexFunction = ctypes.CFUNCTYPE(None, NDXLVertex_p, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_void_p)
+NDXLVertexCallback = ctypes.CFUNCTYPE(None, NDXLVertex_p, ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_void_p)
+NoneVFn = NDXLVertexFunction(0)
+NoneVCb = NDXLVertexCallback(0)
+
+# ^^^^^ Callbacks | constructor and destructor vvvvv
+
+lib.ndxlCreateVertex.restype = NDXLVertex_p
+lib.ndxlCreateVertex.argtypes = [NDXLNetwork_p, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, NDXLVertexFunction, NDXLVertexFunction, NDXLVertexCallback, ctypes.c_void_p]
+
+lib.ndxlCopyVertex.restype = NDXLVertex_p
+lib.ndxlCopyVertex.argtypes = [NDXLVertex_p, NDXLNetwork_p, ctypes.c_bool, ctypes.c_void_p]
+
+lib.ndxlDestroyVertex.restype = ctypes.c_int
+lib.ndxlDestroyVertex.argtypes = [ctypes.POINTER(NDXLVertex_p)]
+
+# ^^^^^ Constructor and destructor | getters vvvvv
+
+lib.ndxlGetVertexCallback.restype = NDXLVertexCallback
+lib.ndxlGetVertexCallback.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexDegree.restype = ctypes.c_size_t
+lib.ndxlGetVertexDegree.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexDegreeIn.restype = ctypes.c_size_t
+lib.ndxlGetVertexDegreeIn.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexDegreeOut.restype = ctypes.c_size_t
+lib.ndxlGetVertexDegreeOut.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexEdges.restype = ctypes.c_int
+lib.ndxlGetVertexEdges.argtypes = [NDXLVertex_p, ctypes.POINTER(NDXLEdge_p)]
+
+lib.ndxlGetVertexFirstEdge.restype = NDXLEdge_p
+lib.ndxlGetVertexFirstEdge.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexFunction.restype = NDXLVertexFunction
+lib.ndxlGetVertexFunction.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexInitialState.restype = ctypes.POINTER(ctypes.c_double)
+lib.ndxlGetVertexInitialState.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexLastEdge.restype = NDXLEdge_p
+lib.ndxlGetVertexLastEdge.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexNeighbour.restype = NDXLVertex_p
+lib.ndxlGetVertexNeighbour.argtypes = [NDXLVertex_p, NDXLEdge_p]
+
+lib.ndxlGetVertexNeighbours.restype = ctypes.c_int
+lib.ndxlGetVertexNeighbours.argtypes = [NDXLVertex_p, ctypes.POINTER(NDXLVertex_p)]
+
+lib.ndxlGetVertexNeighbourState.restype = ctypes.POINTER(ctypes.c_double)
+lib.ndxlGetVertexNeighbourState.argtypes = [NDXLVertex_p, NDXLEdge_p]
+
+lib.ndxlGetVertexNextEdge.restype = NDXLEdge_p
+lib.ndxlGetVertexNextEdge.argtypes = [NDXLVertex_p, NDXLEdge_p]
+
+lib.ndxlGetVertexNoise.restype = NDXLVertexFunction
+lib.ndxlGetVertexNoise.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexOrder.restype = ctypes.c_size_t
+lib.ndxlGetVertexOrder.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexParams.restype = ctypes.c_void_p
+lib.ndxlGetVertexParams.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexParent.restype = NDXLNetwork_p
+lib.ndxlGetVertexParent.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexState.restype = ctypes.POINTER(ctypes.c_double)
+lib.ndxlGetVertexState.argtypes = [NDXLVertex_p]
+
+lib.ndxlGetVertexTime.restype = ctypes.c_double
+lib.ndxlGetVertexTime.argtypes = [NDXLVertex_p]
+
+# ^^^^^ Getters | setters vvvvv
+
+lib.ndxlSetVertexCallback.restype = ctypes.c_int
+lib.ndxlSetVertexCallback.argtypes = [NDXLVertex_p, NDXLVertexCallback]
+
+lib.ndxlSetVertexFunction.restype = ctypes.c_int
+lib.ndxlSetVertexFunction.argtypes = [NDXLVertex_p, NDXLVertexFunction]
+
+lib.ndxlSetVertexNoise.restype = ctypes.c_int
+lib.ndxlSetVertexNoise.argtypes = [NDXLVertex_p, NDXLVertexFunction]
+
+lib.ndxlSetVertexState.restype = ctypes.c_int
+lib.ndxlSetVertexState.argtypes = [NDXLVertex_p, ctypes.POINTER(ctypes.c_double)]
+
+# ^^^^^ Setters | functions vvvvv
+
+lib.ndxlVertexReset.restype = ctypes.c_int
+lib.ndxlVertexReset.argtypes = [NDXLVertex_p]
+
+# ^^^^^ Functions | Python wrappers vvvvv
+
+class vertex:
+	def __init__(self, ptr, args):
+		self._ptr = ptr
+		self._pptr = args
+		self._params = ctypes.cast(self._pptr, ctypes.POINTER(ctypes.py_object)).contents.value
+		self._cplx = self._params[-3]
+
+	def __del__(self):
+		self._ptr = None
+		self._pptr = None
+		self._params = None
+
+	def __bool__(self):
+		return self._ptr != 0
+
+	def __len__(self):
+		_ord = lib.ndxlGetVertexOrder(self._ptr)
+		return (_ord // 2) if self._cplx else _ord
+
+	def __str__(self):
+		return f"'<ndxl.vertex object at " + f"{id(self._ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}" + " {'parent': " + f"<ndxl.network object at {id(self.parent.c_ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}>" + ", 'degree': " + str(lib.ndxlGetVertexDegree(self._ptr)) + ", 'in-degree': " + str(lib.ndxlGetVertexDegreeIn(self._ptr)) + ", 'out-degree': " + str(lib.ndxlGetVertexDegreeOut(self._ptr)) + ", 'state': " + str(self.state) + ", 'initial-state': " + str(self.initial_state) + ", 'time': " + str(lib.ndxlGetVertexTime(self._ptr)) + ", 'function': " + str(self._params[0]) + ", 'noise': " + str(self._params[1]) + ", 'callback': " + str(self._params[2]) + "}>'"
+
+	def __repr__(self):
+		return f"NDXL vertex\n===========\n\nParent: <ndxl.network object at {id(self.parent.c_ptr):#0{int(platform.architecture()[0][:-3]) // 4 + 2}X}>\nState: {self.state}\nInitial state: {self.initial_state}\nDegree: {lib.ndxlGetVertexDegree(self._ptr)}\nIn-degree: {lib.ndxlGetVertexDegreeIn(self._ptr)}\nOut-degree: {lib.ndxlGetVertexDegreeOut(self._ptr)}\nFunction: {self._params[0]}\nNoise: {self._params[1]}\nCallback: {self._params[2]}\nTime: {lib.ndxlGetVertexTime(self._ptr)}\n"
+
+	@property
+	def c_ptr(self):
+		return self._ptr
+
+	def destroy(self):
+		_res = lib.ndxlDestroyVertex(ctypes.pointer(self._ptr))
+		del self._pptr
+		del self._params
+		return _res
+
+	@property
+	def callback(self):
+		return lib.ndxlGetVertexCallback(self._ptr)
+
+	@callback.setter
+	def callback(self, cb):
+		self._params[2] = cb
+		return lib.ndxlSetVertexCallback(self._ptr, NoneVCb if cb is None else _vcb_bridge)
+
+	@property
+	def cplx(self):
+		return self._cplx
+
+	@property
+	def degree(self):
+		return lib.ndxlGetVertexDegree(self._ptr)
+
+	@property
+	def degree_in(self):
+		return lib.ndxlGetVertexDegreeIn(self._ptr)
+
+	@property
+	def degree_out(self):
+		return lib.ndxlGetVertexDegreeOut(self._ptr)
+
+	@property
+	def edges(self):
+		from .edge import edge
+		_edge = lib.ndxlGetVertexFirstEdge(self._ptr)
+		while _edge:
+			yield edge(_edge, lib.ndxlGetEdgeParams(_edge))
+			_edge = lib.ndxlGetVertexNextEdge(self._ptr, _edge)
+
+	@property
+	def func(self):
+		return lib.ndxlGetVertexFunction(self._ptr)
+
+	@func.setter
+	def func(self, fn):
+		self._params[0] = fn
+		return lib.ndxlSetVertexFunction(self._ptr, NoneVFn if fn is None else _vfunc_bridge)
+
+	@property
+	def initial_state(self):
+		return lib.ndxlGetVertexInitialState(self._ptr)[:lib.ndxlGetVertexOrder(self._ptr)]
+
+	def neighbour(self, ed):
+		_vert = lib.ndxlGetVertexNeighbour(self._ptr, ed.c_ptr)
+		return vertex(_vert, lib.ndxlGetVertexParams(_vert))
+
+	def neighbour_state(self, ed):
+		_order = self.neighbour(ed).order
+		return lib.ndxlGetVertexNeighbourState(self._ptr, ed.c_ptr)[:_order]
+
+	@property
+	def neighbours(self):
+		for _edge in self.edges:
+			yield self.neighbour(_edge)
+
+	@property
+	def noise(self):
+		return lib.ndxlGetVertexNoise(self._ptr)
+
+	@noise.setter
+	def noise(self, zeta):
+		self._params[1] = zeta
+		return lib.ndxlSetVertexNoise(self._ptr, NoneVFn if zeta is None else _vnoise_bridge)
+
+	@property
+	def order(self):
+		return lib.ndxlGetVertexOrder(self._ptr)
+
+	@property
+	def parent(self):
+		from .network import network
+		_nwk = lib.ndxlGetVertexParent(self._ptr)
+		return network(_nwk, lib.ndxlGetNetworkParams(_nwk))
+
+	@property
+	def shape(self):
+		return self._params[-2]
+
+	@property
+	def state(self):
+		_ord = self.order
+		_state = np.ctypeslib.as_array(lib.ndxlGetVertexState(self._ptr), shape=(_ord,))
+		if self._cplx:
+			return (_state[:_ord // 2] + 1j * _state[_ord // 2: _ord]).reshape(self._params[-2])
+		return _state.reshape(self._params[-2])
+
+	@state.setter
+	def state(self, st):
+		_state = None
+		_nstate = 0
+		if st is not None:
+			_arr = np.asarray(st)
+			if self._cplx:
+				_ord = lib.ndxlGetVertexOrder(self._ptr) // 2
+				_st = np.asarray(_arr.flatten(), dtype=complex)
+				_nstate = len(_st)
+				if _nstate != _ord:
+					raise ValueError(f"Attempting to assign {_nstate}-element state vector to vertex of order {_ord}.")
+				_state = np.ctypeslib.as_ctypes(np.append(_st.real, _st.imag))
+			else:
+				_ord = lib.ndxlGetVertexOrder(self._ptr)
+				_st = np.asarray(_arr.flatten(), dtype=float)
+				_nstate = len(_st)
+				if _nstate != _ord:
+					raise ValueError(f"Attempting to assign {_nstate}-element state vector to vertex of order {_ord}.")
+				_state = np.ctypeslib.as_ctypes(_st)
+		return lib.ndxlSetVertexState(self._ptr, _state)
+
+	@property
+	def time(self):
+		return lib.ndxlGetVertexTime(self._ptr)
+
+	def create_edge(self, vert, state=None, delay=0., directed=False, func=None, noise=None, cb=None, args=None, cplx=False):
+		from .edge import edge, _efunc_bridge, _enoise_bridge, _ecb_bridge, NoneEFn, NoneECb
+		_state = None
+		_nstate = 0
+		_sstate = ()
+		_cplx = cplx
+		if state is not None:
+			_arr = np.asarray(state)
+			_sstate = _arr.shape
+			if _arr.dtype == complex:
+				_st = np.asarray(_arr.flatten(), dtype=complex)
+				_nstate = len(_st) * 2
+				_state = np.ctypeslib.as_ctypes(np.append(_st.real, _st.imag))
+				_cplx = True
+			else:
+				_st = np.asarray(_arr.flatten(), dtype=float)
+				_nstate = len(_st)
+				_state = np.ctypeslib.as_ctypes(_st)
+		_pptr = ctypes.cast(ctypes.pointer(ctypes.py_object([func, noise, cb, _cplx, _sstate, () if args is None else copy.deepcopy(args)])), ctypes.c_void_p)
+		return edge(lib.ndxlCreateEdge(self._ptr, vert if isinstance(vert, NDXLVertex_p) else vert.c_ptr, _state, _nstate, delay, directed, NoneEFn if func is None else _efunc_bridge, NoneEFn if noise is None else _enoise_bridge, NoneECb if cb is None else _ecb_bridge, _pptr), _pptr)
+
+@NDXLVertexFunction
+def _vfunc_bridge(vert, dstate, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_func = _meta[0]
+	if _func:
+		_userdata = _meta[-1]
+		_v = vertex(vert, lib.ndxlGetVertexParams(vert))
+		_ord = _v.order
+		_inview = np.ctypeslib.as_array(state, shape=(_ord,))
+		_outview = np.ctypeslib.as_array(dstate, shape=(_ord,))
+		if _v.cplx:
+			_len = len(_v)
+			_result = np.asarray(_func(_v, (_inview[:_len] + 1j * _inview[_len: _ord]).reshape(_v.shape), time, *_userdata)).flatten()
+			_outview[:] = np.append(_result.real, _result.imag)
+		else:
+			_outview[:] = np.asarray(_func(_v, _inview.reshape(_v.shape), time, *_userdata)).flatten()
+
+@NDXLVertexFunction
+def _vnoise_bridge(vert, dstate, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_noise = _meta[1]
+	if _noise:
+		_userdata = _meta[-1]
+		_v = vertex(vert, lib.ndxlGetVertexParams(vert))
+		_ord = _v.order
+		_inview = np.ctypeslib.as_array(state, shape=(_ord,))
+		_outview = np.ctypeslib.as_array(dstate, shape=(_ord,))
+		if _v.cplx:
+			_len = len(_v)
+			_result = np.asarray(_noise(_v, (_inview[:_len] + 1j * _inview[_len: _ord]).reshape(_v.shape), time, *_userdata)).flatten()
+			_outview[:] = np.append(_result.real, _result.imag)
+		else:
+			_outview[:] = np.asarray(_noise(_v, _inview.reshape(_v.shape), time, *_userdata)).flatten()
+	else:
+		_outview = np.ctypeslib.as_array(dstate, shape=(_ord,))
+
+@NDXLVertexCallback
+def _vcb_bridge(vert, state, time, args):
+	_meta = ctypes.cast(args, ctypes.POINTER(ctypes.py_object)).contents.value
+	_cb = _meta[2]
+	if _cb:
+		_userdata = _meta[-1]
+		_v = vertex(vert, lib.ndxlGetVertexParams(vert))
+		_ord = _v.order
+		_view = np.ctypeslib.as_array(state, shape=(_ord,))
+		if _v.cplx:
+			_len = len(_v)
+			_tview = (_view[:_len] + 1j * _view[_len: _ord]).reshape(_v.shape)
+			_cb(_v, _tview, time, *_userdata)
+			_tview = _tview.flatten()
+			_view[:] = np.append(_tview.real, _tview.imag)
+		else:
+			_cb(_v, _view.reshape(_v.shape), time, *_userdata)
+
+# ^^^^^ Python wrappers

ndxl-1.0.0/src/ndxl.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: ndxl
+Version: 1.0.0
+Summary: Network Dynamics eXperimentation Library
+Author: Ethan Codron
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

ndxl-1.0.0/src/ndxl.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+src/ndxl/__init__.py
+src/ndxl/core.py
+src/ndxl/edge.py
+src/ndxl/network.py
+src/ndxl/vertex.py
+src/ndxl.egg-info/PKG-INFO
+src/ndxl.egg-info/SOURCES.txt
+src/ndxl.egg-info/dependency_links.txt
+src/ndxl.egg-info/top_level.txt
+src/ndxl/lib/NDXL.dll
+src/ndxl/lib/libNDXL.so

ndxl-1.0.0/src/ndxl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ndxl-1.0.0/src/ndxl.egg-info/top_level.txt

@@ -0,0 +1 @@
+ndxl