nd2py package

nd2py.no_copy_value()

class nd2py.Empty(nettype: Literal['node', 'edge', 'scalar'] | None = None)

Bases: Symbol

n_operands = 0

__init__(nettype: Literal['node', 'edge', 'scalar'] | None = None)

Initialize a Symbol node.

This constructor sets the nettype, sanitizes and attaches child operands, and then triggers a nettype inference pass on the whole expression tree.

Parameters:

• *operands – Child operands of this symbol. The number of operands must match n_operands of the concrete subclass. Non-symbol scalar values are automatically wrapped as Number symbols.

• nettype (Optional[NetType | Set[NetType]]) – Nettype constraint for this symbol, such as "node", "edge", or "scalar", or a set of allowed nettypes. If provided, it is propagated through the tree by infer_nettype().

map_nettype() → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

nd2py.aggr

alias of Aggr

class nd2py.Csch(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.pow2

alias of Pow2

nd2py.cos

alias of Cos

nd2py.log

alias of Log

class nd2py.SplitByMul

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs) → _Type

visit_Mul(node: Mul, *args, **kwargs) → _Type

visit_Div(node: Div, *args, **kwargs) → _Type

merge_coefficients(items: List[Symbol], *args, **kwargs) → List[Symbol]

Merge coefficients from the symbols.

class nd2py.Sour(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

classmethod map_nettype(*children_nettypes: Literal['node', 'edge', 'scalar']) → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

nd2py.get_copy_value()

nd2py.no_nettype_inference()

class nd2py.Csc(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.maximum(*operands)

class nd2py.Cot(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.set_fitable()

nd2py.phi_s

alias of Sour

nd2py.sinh

alias of Sinh

nd2py.min

alias of Min

nd2py.regular

alias of Regular

class nd2py.Add(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

nd2py.no_set_fitable()

class nd2py.LogAbs(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Rgga(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Aggr

nd2py.minimum(*operands)

class nd2py.Sec(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.cosh

alias of Cosh

nd2py.sigmoid

alias of Sigmoid

class nd2py.Identity(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.div

alias of Div

class nd2py.Cosh(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.reg

alias of Regular

nd2py.pow

alias of Pow

class nd2py.FoldConstant(fold_fitable: bool = True, fold_constant: bool = True)

Bases: Visitor

访问器，用于将表达式中不含 Number 的子表达式折叠为 Constant。

__init__(fold_fitable: bool = True, fold_constant: bool = True)

generic_visit(node, *args, **kwargs)

visit_Empty(node: Symbol, *args, **kwargs)

visit_Number(node: Number, *args, **kwargs)

visit_Variable(node: Variable, *args, **kwargs)

class nd2py.TreePrinter

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs) → _Type

visit_Empty(node: Symbol, *args, **kwargs) → _Type

visit_Number(node: Number, *args, **kwargs) → _Type

visit_Variable(node: Variable, *args, **kwargs) → _Type

visit_Add(node: Add, *args, **kwargs) → _Type

visit_Mul(node: Mul, *args, **kwargs) → _Type

class nd2py.Min(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

nd2py.Constant(value, nettype: Literal['node', 'edge', 'scalar'] = 'scalar') → Number

一个工厂函数，返回一个 fitable 为 False 的 Number 对象。

nd2py.arcsin

alias of Arcsin

nd2py.tanh

alias of Tanh

nd2py.parse(expression: str, variables: Dict[str, Symbol] = None, callables: Dict[str, callable] = None) → Symbol

nd2py.rgga

alias of Rgga

nd2py.max

alias of Max

nd2py.pow3

alias of Pow3

nd2py.add

alias of Add

nd2py.mul

alias of Mul

nd2py.neg

alias of Neg

nd2py.warn_once(warn_name, maxsize=None)

This function is used to limit the number of times a warning is issued

nd2py.logabs

alias of LogAbs

nd2py.phi_t

alias of Targ

nd2py.setup_lazy_imports(module_name: str, import_mapping: Dict[str, Tuple[str, str]])

Set up lazy imports for a module’s __init__.py.

Returns (__getattr__, __dir__, __all__) which should be assigned at the module level so that from package import OptionalClass works without importing the optional dependency until it is actually needed.

Parameters:

• module_name – The __name__ of the calling module.

• import_mapping – A dict mapping attribute names to (module_path, requires) tuples. module_path is a relative import path (e.g. ".torch_calc") and requires is the optional-dependency group name (e.g. "nn") shown in the error message when the dependency is missing.

Usage:

# __init__.py
from .core import CoreClass
from ..utils.lazy_loader import setup_lazy_imports

if TYPE_CHECKING:
    from .optional import OptionalClass

__getattr__, __dir__, __all__ = setup_lazy_imports(__name__, {
    "OptionalClass": (".optional", "nn"),
})

nd2py.sub

alias of Sub

class nd2py.Inv(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Aggr(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

classmethod map_nettype(*children_nettypes: Literal['node', 'edge', 'scalar']) → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

class nd2py.Cos(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Regular(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

class nd2py.Pow(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

nd2py.set_copy_value(value: bool)

nd2py.variables(vars, *args, **kwargs)

一个工厂函数，返回一个或多个 Variable 对象。 如果 vars 中包含空格，则认为是多个变量的名字，并返回一个列表；否则认为是单个变量的名字，并返回一个 Variable 对象。

nd2py.csc

alias of Csc

class nd2py.Number(value, nettype: Literal['node', 'edge', 'scalar'] = 'scalar', fitable=None)

Bases: Symbol

n_operands = 0

__init__(value, nettype: Literal['node', 'edge', 'scalar'] = 'scalar', fitable=None)

Initialize a Symbol node.

This constructor sets the nettype, sanitizes and attaches child operands, and then triggers a nettype inference pass on the whole expression tree.

Parameters:

• *operands – Child operands of this symbol. The number of operands must match n_operands of the concrete subclass. Non-symbol scalar values are automatically wrapped as Number symbols.

• nettype (Optional[NetType | Set[NetType]]) – Nettype constraint for this symbol, such as "node", "edge", or "scalar", or a set of allowed nettypes. If provided, it is propagated through the tree by infer_nettype().

map_nettype() → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

get_nettype_range() → Set[Literal['node', 'edge', 'scalar']]

获取此节点可能产生的所有 nettype 值域，并在首次调用时缓存到类属性中。

property nettype_range: Set[Literal['node', 'edge', 'scalar']]

获取此节点可能产生的所有 nettype 值域，并在首次调用时缓存到类属性中。

nd2py.targ

alias of Targ

class nd2py.NumpyCalc

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs)

visit_Empty(node: Empty, *args, **kwargs)

visit_Number(node: Number, *args, **kwargs)

visit_Variable(node: Variable, *args, **kwargs)

visit_Add(node: Add, x1, x2, *args, **kwargs)

visit_Sub(node: Sub, x1, x2, *args, **kwargs)

visit_Mul(node: Mul, x1, x2, *args, **kwargs)

visit_Div(node: Div, x1, x2, *args, **kwargs)

visit_Pow(node: Pow, x1, x2, *args, **kwargs)

visit_Max(node: Max, x1, x2, *args, **kwargs)

visit_Min(node: Min, x1, x2, *args, **kwargs)

visit_Identity(node: Identity, x, *args, **kwargs)

visit_Sin(node: Sin, x, *args, **kwargs)

visit_Cos(node: Cos, x, *args, **kwargs)

visit_Tan(node: Tan, x, *args, **kwargs)

visit_Sec(node: Sec, x, *args, **kwargs)

visit_Csc(node: Csc, x, *args, **kwargs)

visit_Cot(node: Cot, x, *args, **kwargs)

visit_Log(node: Log, x, *args, **kwargs)

visit_LogAbs(node: LogAbs, x, *args, **kwargs)

visit_Exp(node: Exp, x, *args, **kwargs)

visit_Abs(node: Abs, x, *args, **kwargs)

visit_Neg(node: Neg, x, *args, **kwargs)

visit_Inv(node: Inv, x, *args, **kwargs)

visit_Sqrt(node: Sqrt, x, *args, **kwargs)

visit_SqrtAbs(node: SqrtAbs, x, *args, **kwargs)

visit_Pow2(node: Pow2, x, *args, **kwargs)

visit_Pow3(node: Pow3, x, *args, **kwargs)

visit_Arcsin(node: Arcsin, x, *args, **kwargs)

visit_Arccos(node: Arccos, x, *args, **kwargs)

visit_Arctan(node: Arctan, x, *args, **kwargs)

visit_Sinh(node: Sinh, x, *args, **kwargs)

visit_Cosh(node: Cosh, x, *args, **kwargs)

visit_Tanh(node: Tanh, x, *args, **kwargs)

visit_Sech(node: Sech, x, *args, **kwargs)

visit_Csch(node: Csch, x, *args, **kwargs)

visit_Coth(node: Coth, x, *args, **kwargs)

visit_Sigmoid(node: Sigmoid, x, *args, **kwargs)

visit_Regular(node: Regular, x1, x2, *args, **kwargs)

visit_Sour(node: Sour, x, *args, **kwargs)

(, n_nodes or 1) -> (, n_edges or 1)

visit_Targ(node: Targ, x, *args, **kwargs)

(, n_nodes or 1) -> (, n_edges or 1)

visit_Aggr(node: Aggr, x, *args, **kwargs)

(, n_edges or 1) -> (, n_nodes)

visit_Rgga(node: Rgga, x, *args, **kwargs)

(, n_edges or 1) -> (, n_nodes)

visit_Readout(node: Readout, x, *args, **kwargs)

(, n_nodes or n_edges or 1) -> (, 1)

nd2py.readout

alias of Readout

class nd2py.Pow2(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Neg(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Div(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

class nd2py.Symbol(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: NetTypeMixin, TreeMixin, SymbolAPIMixin

n_operands = None

__init__(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Initialize a Symbol node.

This constructor sets the nettype, sanitizes and attaches child operands, and then triggers a nettype inference pass on the whole expression tree.

Parameters:

• *operands – Child operands of this symbol. The number of operands must match n_operands of the concrete subclass. Non-symbol scalar values are automatically wrapped as Number symbols.

• nettype (Optional[NetType | Set[NetType]]) – Nettype constraint for this symbol, such as "node", "edge", or "scalar", or a set of allowed nettypes. If provided, it is propagated through the tree by infer_nettype().

copy()

Return a deep copy of this symbol.

The copied symbol has the same tree structure and values as the original but does not share parent links, so it can be safely inserted into a different expression tree.

Returns:

A deep copy of the current symbol.

Return type:

Symbol

get_numbers(fitable_only: bool = False, float_only: bool = False, scalar_only: bool = False) → List[Number]

Collect all Number nodes contained in this symbol.

Traverses the expression tree in preorder and returns all numeric nodes that satisfy the given filters.

Parameters:

• fitable_only (bool, optional) – If True, return only numbers marked as fitable (trainable) parameters. Defaults to False.

• float_only (bool, optional) – If True, exclude integer-like values (for example exponents that should remain fixed). Defaults to False.

• scalar_only (bool, optional) – If True, only consider scalar numbers (nettype "scalar"). Defaults to False.

Returns:

List of numeric symbol nodes that match the filters.

Return type:

List[Number]

get_parameters(fitable_only: bool = False, float_only: bool = False) → List[float]

Return numeric parameter values contained in this symbol.

This is a convenience wrapper over get_numbers() that extracts the underlying scalar values from Number nodes.

Parameters:

• fitable_only (bool, optional) – If True, return only parameters associated with fitable numbers. Defaults to False.

• float_only (bool, optional) – If True, exclude integer-like parameters. Defaults to False.

Returns:

Flat list of parameter values in traversal order.

Return type:

List[float]

set_parameters(params: List[float], fitable_only: bool = False, float_only: bool = False)

Assign new numeric parameter values to this symbol.

The values in params are consumed in the same order as produced by get_parameters() with the same filter options.

Parameters:

• params (List[float]) – New parameter values to assign.

• fitable_only (bool, optional) – If True, only update fitable parameters and leave others unchanged. Defaults to False.

• float_only (bool, optional) – If True, only update non-integer parameters. Defaults to False.

Raises:

ValueError – If the length of params does not match the number of parameters selected by the filters.

classmethod map_nettype(*children_nettypes: Literal['node', 'edge', 'scalar']) → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

class nd2py.BFGSFit(*args: Any, **kwargs: Any)

Bases: BaseEstimator, RegressorMixin

__init__(expression: Symbol, edge_list=None, num_nodes=None, use_eps=1e-08, method='BFGS', tol=1e-06, options=None, fold_constant=False)

fit(X, y=None)

predict(X)

用拟合好的 expression 去计算新的 X 上的输出。

class nd2py.Variable(name, nettype: Literal['node', 'edge', 'scalar'] = 'scalar')

Bases: Symbol

n_operands = 0

__init__(name, nettype: Literal['node', 'edge', 'scalar'] = 'scalar')

Initialize a Symbol node.

This constructor sets the nettype, sanitizes and attaches child operands, and then triggers a nettype inference pass on the whole expression tree.

Parameters:

• *operands – Child operands of this symbol. The number of operands must match n_operands of the concrete subclass. Non-symbol scalar values are automatically wrapped as Number symbols.

• nettype (Optional[NetType | Set[NetType]]) – Nettype constraint for this symbol, such as "node", "edge", or "scalar", or a set of allowed nettypes. If provided, it is propagated through the tree by infer_nettype().

map_nettype() → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

get_nettype_range() → Set[Literal['node', 'edge', 'scalar']]

获取此节点可能产生的所有 nettype 值域，并在首次调用时缓存到类属性中。

property nettype_range: Set[Literal['node', 'edge', 'scalar']]

获取此节点可能产生的所有 nettype 值域，并在首次调用时缓存到类属性中。

nd2py.arccos

alias of Arccos

class nd2py.Sub(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

class nd2py.Arcsin(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.from_postorder(nodes: List[Symbol | Type[Symbol]], **kwargs) → Symbol

Construct a Symbol tree from a list of Symbols in postorder traversal order.

class nd2py.Simplify

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs) → _Type

remove_nested_unary(node: Symbol, *args, **kwargs) → _Type

visit_Sin(node: Symbol, *args, **kwargs) → _Type

visit_Cos(node: Symbol, *args, **kwargs) → _Type

visit_Tanh(node: Symbol, *args, **kwargs) → _Type

visit_Sigmoid(node: Symbol, *args, **kwargs) → _Type

visit_Sqrt(node: Symbol, *args, **kwargs) → _Type

visit_SqrtAbs(node: Symbol, *args, **kwargs) → _Type

visit_Exp(node: Symbol, *args, **kwargs) → _Type

visit_Log(node: Symbol, *args, **kwargs) → _Type

visit_LogAbs(node: Symbol, *args, **kwargs) → _Type

visit_Readout(node: Readout, *args, **kwargs) → _Type

visit_Number(node: Number, *args, **kwargs) → _Type

visit_Variable(node: Variable, *args, **kwargs) → _Type

visit_Add(node: Add, *args, **kwargs) → _Type

visit_Sub(node: Add, *args, **kwargs) → _Type

visit_Mul(node: Mul, *args, **kwargs) → _Type

visit_Div(node: Mul, *args, **kwargs) → _Type

visit_Neg(node: Neg, *args, **kwargs) → _Type

visit_Inv(node: Inv, *args, **kwargs) → _Type

visit_Aggr(node: Aggr, *args, **kwargs) → _Type

nd2py.prod(*operands)

class nd2py.Sqrt(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.set_nettype_inference(value: bool)

class nd2py.SqrtAbs(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Log(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.no_warn()

Context manager to suppress warnings temporarily

class nd2py.Arctan(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Readout(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

classmethod map_nettype(*children_nettypes: Literal['node', 'edge', 'scalar']) → Literal['node', 'edge', 'scalar'] | None

Default nettype mapping rule for symbol subclasses.

The default behavior enforces that "node" and "edge" nettypes cannot be mixed. If only scalars are present, the result is "scalar"; otherwise it follows the presence of "node" or "edge".

Parameters:

*children_nettypes (NetType) – Nettypes of the child operands.

Returns:

Inferred nettype for the parent symbol, or None if the combination is invalid or cannot be determined.

Return type:

Optional[NetType]

Raises:

ValueError – If the number of child nettypes does not match cls.n_operands.

class nd2py.Tanh(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.cot

alias of Cot

class nd2py.Sech(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.StringPrinter

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs) → _Type

visit_Empty(node: Empty, *args, **kwargs) → _Type

visit_Number(node: Number, *args, **kwargs) → _Type

visit_Variable(node: Variable, *args, **kwargs) → _Type

visit_Add(node: Add, *args, **kwargs) → _Type

visit_Sub(node: Sub, *args, **kwargs) → _Type

visit_Mul(node: Mul, *args, **kwargs) → _Type

visit_Div(node: Div, *args, **kwargs) → _Type

visit_Pow(node: Pow, *args, **kwargs) → _Type

visit_Neg(node: Neg, *args, **kwargs) → _Type

visit_Inv(node: Inv, *args, **kwargs) → _Type

visit_Pow2(node: Pow2, *args, **kwargs) → _Type

visit_Pow3(node: Pow3, *args, **kwargs) → _Type

visit_Sour(node: Sour, *args, **kwargs) → _Type

visit_Targ(node: Targ, *args, **kwargs) → _Type

visit_Aggr(node: Aggr, *args, **kwargs) → _Type

visit_Rgga(node: Rgga, *args, **kwargs) → _Type

nd2py.nettype_inference()

class nd2py.Max(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

nd2py.sum(*operands)

nd2py.sqrtabs

alias of SqrtAbs

class nd2py.Tan(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Abs(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.tan

alias of Tan

class nd2py.Sinh(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Arccos(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.FixNetType

Bases: Visitor

generic_visit(node, *args, **kwargs) → _Type

direction = ‘top-down’: 每个 node 的 nettype 由 kwargs[‘nettype’] 决定。 direction = ‘bottom-up’: 每个 node 的 nettype 由其 operands 决定。只保证每个 node 运算不会出错即可，不需要对 kwargs[‘nettype’] 负责

visit_Number(node: Number, *args, **kwargs) → _Type

visit_Variable(node: Variable, *args, **kwargs) → _Type

visit_BinaryOp(node, *args, **kwargs) → _Type

visit_Add(node, *args, **kwargs) → _Type

visit_Sub(node, *args, **kwargs) → _Type

visit_Mul(node, *args, **kwargs) → _Type

visit_Div(node, *args, **kwargs) → _Type

visit_Pow(node, *args, **kwargs) → _Type

visit_Max(node, *args, **kwargs) → _Type

visit_Min(node, *args, **kwargs) → _Type

visit_Aggr(node, *args, **kwargs) → _Type

visit_Rgga(node, *args, **kwargs) → _Type

visit_Sour(node, *args, **kwargs) → _Type

visit_Targ(node, *args, **kwargs) → _Type

visit_Readout(node, *args, **kwargs) → _Type

fix_nettype(node: Symbol, *args, **kwargs) → Symbol

edge_to_node(node: Symbol, *args, **kwargs) → Symbol

node_to_edge(node: Symbol, *args, **kwargs) → Symbol

edge_to_scalar(node: Symbol, *args, **kwargs) → Symbol

node_to_scalar(node: Symbol, *args, **kwargs) → Symbol

scalar_to_node(node: Symbol, *args, **kwargs) → Symbol

scalar_to_edge(node: Symbol, *args, **kwargs) → Symbol

nd2py.sin

alias of Sin

nd2py.sec

alias of Sec

class nd2py.Sigmoid(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.exp

alias of Exp

nd2py.rho

alias of Aggr

class nd2py.Mul(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 2

nd2py.sour

alias of Sour

nd2py.sech

alias of Sech

class nd2py.Pow3(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Exp(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Targ(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Sour

nd2py.inv

alias of Inv

nd2py.from_preorder(nodes: List[Symbol | Type[Symbol]], **kwargs) → Symbol

Construct a Symbol tree from a list of Symbols in preorder traversal order.

nd2py.abs

alias of Abs

nd2py.sqrt

alias of Sqrt

class nd2py.SplitByAdd

Bases: Visitor

generic_visit(node: Symbol, *args, **kwargs) → _Type

visit_Add(node: Add, *args, **kwargs) → _Type

visit_Sub(node: Sub, *args, **kwargs) → _Type

visit_Mul(node: Mul, *args, **kwargs) → _Type

visit_Div(node: Div, *args, **kwargs) → _Type

visit_Neg(node: Neg, *args, **kwargs) → _Type

visit_Sour(node: Sour, *args, **kwargs) → _Type

visit_Targ(node: Targ, *args, **kwargs) → _Type

visit_Aggr(node: Aggr, *args, **kwargs) → _Type

visit_Rgga(node: Rgga, *args, **kwargs) → _Type

visit_Readout(node: Readout, *args, **kwargs) → _Type

merge_bias(items: List[Symbol], *args, **kwargs) → List[Symbol]

Merge bias terms in the node.

nd2py.csch

alias of Csch

class nd2py.Sin(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

class nd2py.Coth(*operands, nettype: Literal['node', 'edge', 'scalar'] | Set[Literal['node', 'edge', 'scalar']] | None = None)

Bases: Symbol

n_operands = 1

nd2py.arctan

alias of Arctan

Subpackages

• nd2py.core package
  • no_copy_value()
  • Empty
    • Empty.n_operands
    • Empty.__init__()
    • Empty.map_nettype()
  • aggr
  • Csch
    • Csch.n_operands
  • pow2
  • cos
  • log
  • SplitByMul
    • SplitByMul.generic_visit()
    • SplitByMul.visit_Mul()
    • SplitByMul.visit_Div()
    • SplitByMul.merge_coefficients()
  • Sour
    • Sour.n_operands
    • Sour.map_nettype()
  • get_copy_value()
  • no_nettype_inference()
  • Csc
    • Csc.n_operands
  • maximum()
  • Cot
    • Cot.n_operands
  • set_fitable()
  • phi_s
  • sinh
  • min
  • regular
  • Add
    • Add.n_operands
  • no_set_fitable()
  • LogAbs
    • LogAbs.n_operands
  • Rgga
  • minimum()
  • Sec
    • Sec.n_operands
  • cosh
  • sigmoid
  • Identity
    • Identity.n_operands
  • div
  • Cosh
    • Cosh.n_operands
  • reg
  • pow
  • FoldConstant
    • FoldConstant.__init__()
    • FoldConstant.generic_visit()
    • FoldConstant.visit_Empty()
    • FoldConstant.visit_Number()
    • FoldConstant.visit_Variable()
  • TreePrinter
    • TreePrinter.generic_visit()
    • TreePrinter.visit_Empty()
    • TreePrinter.visit_Number()
    • TreePrinter.visit_Variable()
    • TreePrinter.visit_Add()
    • TreePrinter.visit_Mul()
  • Min
    • Min.n_operands
  • Constant()
  • arcsin
  • tanh
  • parse()
  • rgga
  • max
  • pow3
  • add
  • mul
  • neg
  • warn_once()
  • logabs
  • phi_t
  • setup_lazy_imports()
  • sub
  • Inv
    • Inv.n_operands
  • Aggr
    • Aggr.n_operands
    • Aggr.map_nettype()
  • Cos
    • Cos.n_operands
  • Regular
    • Regular.n_operands
  • Pow
    • Pow.n_operands
  • set_copy_value()
  • variables()
  • csc
  • Number
    • Number.n_operands
    • Number.__init__()
    • Number.map_nettype()
    • Number.get_nettype_range()
    • Number.nettype_range
  • targ
  • NumpyCalc
    • NumpyCalc.generic_visit()
    • NumpyCalc.visit_Empty()
    • NumpyCalc.visit_Number()
    • NumpyCalc.visit_Variable()
    • NumpyCalc.visit_Add()
    • NumpyCalc.visit_Sub()
    • NumpyCalc.visit_Mul()
    • NumpyCalc.visit_Div()
    • NumpyCalc.visit_Pow()
    • NumpyCalc.visit_Max()
    • NumpyCalc.visit_Min()
    • NumpyCalc.visit_Identity()
    • NumpyCalc.visit_Sin()
    • NumpyCalc.visit_Cos()
    • NumpyCalc.visit_Tan()
    • NumpyCalc.visit_Sec()
    • NumpyCalc.visit_Csc()
    • NumpyCalc.visit_Cot()
    • NumpyCalc.visit_Log()
    • NumpyCalc.visit_LogAbs()
    • NumpyCalc.visit_Exp()
    • NumpyCalc.visit_Abs()
    • NumpyCalc.visit_Neg()
    • NumpyCalc.visit_Inv()
    • NumpyCalc.visit_Sqrt()
    • NumpyCalc.visit_SqrtAbs()
    • NumpyCalc.visit_Pow2()
    • NumpyCalc.visit_Pow3()
    • NumpyCalc.visit_Arcsin()
    • NumpyCalc.visit_Arccos()
    • NumpyCalc.visit_Arctan()
    • NumpyCalc.visit_Sinh()
    • NumpyCalc.visit_Cosh()
    • NumpyCalc.visit_Tanh()
    • NumpyCalc.visit_Sech()
    • NumpyCalc.visit_Csch()
    • NumpyCalc.visit_Coth()
    • NumpyCalc.visit_Sigmoid()
    • NumpyCalc.visit_Regular()
    • NumpyCalc.visit_Sour()
    • NumpyCalc.visit_Targ()
    • NumpyCalc.visit_Aggr()
    • NumpyCalc.visit_Rgga()
    • NumpyCalc.visit_Readout()
  • readout
  • Pow2
    • Pow2.n_operands
  • Neg
    • Neg.n_operands
  • Div
    • Div.n_operands
  • Symbol
    • Symbol.n_operands
    • Symbol.__init__()
    • Symbol.copy()
    • Symbol.get_numbers()
    • Symbol.get_parameters()
    • Symbol.set_parameters()
    • Symbol.map_nettype()
  • BFGSFit
    • BFGSFit.__init__()
    • BFGSFit.fit()
    • BFGSFit.predict()
  • Variable
    • Variable.n_operands
    • Variable.__init__()
    • Variable.map_nettype()
    • Variable.get_nettype_range()
    • Variable.nettype_range
  • arccos
  • Sub
    • Sub.n_operands
  • Arcsin
    • Arcsin.n_operands
  • prod()
  • from_postorder()
  • Simplify
    • Simplify.generic_visit()
    • Simplify.remove_nested_unary()
    • Simplify.visit_Sin()
    • Simplify.visit_Cos()
    • Simplify.visit_Tanh()
    • Simplify.visit_Sigmoid()
    • Simplify.visit_Sqrt()
    • Simplify.visit_SqrtAbs()
    • Simplify.visit_Exp()
    • Simplify.visit_Log()
    • Simplify.visit_LogAbs()
    • Simplify.visit_Readout()
    • Simplify.visit_Number()
    • Simplify.visit_Variable()
    • Simplify.visit_Add()
    • Simplify.visit_Sub()
    • Simplify.visit_Mul()
    • Simplify.visit_Div()
    • Simplify.visit_Neg()
    • Simplify.visit_Inv()
    • Simplify.visit_Aggr()
  • Sqrt
    • Sqrt.n_operands
  • set_nettype_inference()
  • SqrtAbs
    • SqrtAbs.n_operands
  • Log
    • Log.n_operands
  • no_warn()
  • Arctan
    • Arctan.n_operands
  • Readout
    • Readout.n_operands
    • Readout.map_nettype()
  • Tanh
    • Tanh.n_operands
  • cot
  • Sech
    • Sech.n_operands
  • StringPrinter
    • StringPrinter.generic_visit()
    • StringPrinter.visit_Empty()
    • StringPrinter.visit_Number()
    • StringPrinter.visit_Variable()
    • StringPrinter.visit_Add()
    • StringPrinter.visit_Sub()
    • StringPrinter.visit_Mul()
    • StringPrinter.visit_Div()
    • StringPrinter.visit_Pow()
    • StringPrinter.visit_Neg()
    • StringPrinter.visit_Inv()
    • StringPrinter.visit_Pow2()
    • StringPrinter.visit_Pow3()
    • StringPrinter.visit_Sour()
    • StringPrinter.visit_Targ()
    • StringPrinter.visit_Aggr()
    • StringPrinter.visit_Rgga()
  • nettype_inference()
  • Max
    • Max.n_operands
  • sum()
  • sqrtabs
  • Tan
    • Tan.n_operands
  • Abs
    • Abs.n_operands
  • tan
  • Sinh
    • Sinh.n_operands
  • Arccos
    • Arccos.n_operands
  • FixNetType
    • FixNetType.generic_visit()
    • FixNetType.visit_Number()
    • FixNetType.visit_Variable()
    • FixNetType.visit_BinaryOp()
    • FixNetType.visit_Add()
    • FixNetType.visit_Sub()
    • FixNetType.visit_Mul()
    • FixNetType.visit_Div()
    • FixNetType.visit_Pow()
    • FixNetType.visit_Max()
    • FixNetType.visit_Min()
    • FixNetType.visit_Aggr()
    • FixNetType.visit_Rgga()
    • FixNetType.visit_Sour()
    • FixNetType.visit_Targ()
    • FixNetType.visit_Readout()
    • FixNetType.fix_nettype()
    • FixNetType.edge_to_node()
    • FixNetType.node_to_edge()
    • FixNetType.edge_to_scalar()
    • FixNetType.node_to_scalar()
    • FixNetType.scalar_to_node()
    • FixNetType.scalar_to_edge()
  • sin
  • sec
  • Sigmoid
    • Sigmoid.n_operands
  • exp
  • rho
  • Mul
    • Mul.n_operands
  • sour
  • sech
  • Pow3
    • Pow3.n_operands
  • Exp
    • Exp.n_operands
  • Targ
  • inv
  • from_preorder()
  • abs
  • sqrt
  • csch
  • SplitByAdd
    • SplitByAdd.generic_visit()
    • SplitByAdd.visit_Add()
    • SplitByAdd.visit_Sub()
    • SplitByAdd.visit_Mul()
    • SplitByAdd.visit_Div()
    • SplitByAdd.visit_Neg()
    • SplitByAdd.visit_Sour()
    • SplitByAdd.visit_Targ()
    • SplitByAdd.visit_Aggr()
    • SplitByAdd.visit_Rgga()
    • SplitByAdd.visit_Readout()
    • SplitByAdd.merge_bias()
  • Sin
    • Sin.n_operands
  • Coth
    • Coth.n_operands
  • arctan
  • Subpackages
    • nd2py.core.basic package
      • Submodules
      • nd2py.core.basic.get_copy module
      • nd2py.core.basic.get_length module
    • nd2py.core.calc package
      • NumpyCalc
      • setup_lazy_imports()
      • Submodules
      • nd2py.core.calc.numpy_calc module
      • nd2py.core.calc.torch_calc module
    • nd2py.core.context package
      • Submodules
      • nd2py.core.context.copy_value module
      • nd2py.core.context.nettype_inference module
      • nd2py.core.context.set_fitable module
      • nd2py.core.context.warn_once module
    • nd2py.core.converter package
      • Submodules
      • nd2py.core.converter.from_postorder module
      • nd2py.core.converter.from_preorder module
      • nd2py.core.converter.parser module
      • nd2py.core.converter.string_printer module
      • nd2py.core.converter.tree_printer module
    • nd2py.core.nettype package
      • Submodules
      • nd2py.core.nettype.inter_nettype module
      • nd2py.core.nettype.nettype_mixin module
    • nd2py.core.symbols package
      • Submodules
      • nd2py.core.symbols.empty module
      • nd2py.core.symbols.functions module
      • nd2py.core.symbols.number module
      • nd2py.core.symbols.operands module
      • nd2py.core.symbols.symbol module
      • nd2py.core.symbols.variable module
    • nd2py.core.transform package
      • Submodules
      • nd2py.core.transform.bfgs_fit module
      • nd2py.core.transform.fix_nettype module
      • nd2py.core.transform.fold_constant module
      • nd2py.core.transform.reduce module
      • nd2py.core.transform.simplify module
      • nd2py.core.transform.split_by_add module
      • nd2py.core.transform.split_by_mul module
    • nd2py.core.tree package
      • Submodules
      • nd2py.core.tree.iter_postorder module
      • nd2py.core.tree.iter_preorder module
      • nd2py.core.tree.match module
      • nd2py.core.tree.tree_mixin module
  • Submodules
  • nd2py.core.base_visitor module
    • yield_nothing()
    • Visitor
      • Visitor.generic_visit()
  • nd2py.core.symbol_api module
    • SymbolAPIMixin
      • SymbolAPIMixin.to_str()
      • SymbolAPIMixin.to_tree()
      • SymbolAPIMixin.eval()
      • SymbolAPIMixin.eval_torch()
      • SymbolAPIMixin.split_by_add()
      • SymbolAPIMixin.split_by_mul()
      • SymbolAPIMixin.fix_nettype()
      • SymbolAPIMixin.simplify()
• nd2py.dataset package
  • Submodules
  • nd2py.dataset.tokenizer module
• nd2py.generator package
  • Subpackages
    • nd2py.generator.data package
      • Submodules
      • nd2py.generator.data.gmm_generator module
      • nd2py.generator.data.subeq_generator module
    • nd2py.generator.eq package
      • Submodules
      • nd2py.generator.eq.enumerator module
      • nd2py.generator.eq.gplearn_generator module
      • nd2py.generator.eq.metaai_generator module
      • nd2py.generator.eq.snip_generator module
• nd2py.search package
  • setup_lazy_imports()
  • Subpackages
    • nd2py.search.e2esr package
      • Submodules
      • nd2py.search.e2esr.e2esr_config module
      • nd2py.search.e2esr.e2esr_dataset module
      • nd2py.search.e2esr.e2esr_generator module
      • nd2py.search.e2esr.e2esr_model module
      • nd2py.search.e2esr.e2esr_tokenizer module
      • nd2py.search.e2esr.e2esr_train module
    • nd2py.search.gp package
      • Submodules
      • nd2py.search.gp.gp module
    • nd2py.search.llmsr package
      • Subpackages
      • Submodules
      • nd2py.search.llmsr.llmsr module
    • nd2py.search.mcts package
      • Submodules
      • nd2py.search.mcts.mcts module
      • nd2py.search.mcts.mcts_forest module
      • nd2py.search.mcts.utils module
    • nd2py.search.ndformer package
      • NDFormerDataGenerator
      • NDFormerEqtreeGenerator
      • NDFormerGraphGenerator
      • NDFormerModelConfig
      • NDFormerTokenizer
      • setup_lazy_imports()
      • Submodules
      • nd2py.search.ndformer.ndformer_config module
      • nd2py.search.ndformer.ndformer_dataset module
      • nd2py.search.ndformer.ndformer_generator module
      • nd2py.search.ndformer.ndformer_mcts module
      • nd2py.search.ndformer.ndformer_model module
      • nd2py.search.ndformer.ndformer_model_flash_ansr module
      • nd2py.search.ndformer.ndformer_tokenizer module
• nd2py.utils package
  • AttrDict
    • AttrDict.__init__()
    • AttrDict.load_yaml()
    • AttrDict.load_yaml_str()
  • EqualizeNormalize
    • EqualizeNormalize.__init__()
    • EqualizeNormalize.inverse()
  • MAE_score()
  • MAPE_score()
  • NamedTimer
    • NamedTimer.__init__()
    • NamedTimer.add()
    • NamedTimer.clear()
    • NamedTimer.to_str()
    • NamedTimer.names
    • NamedTimer.time
    • NamedTimer.count
    • NamedTimer.get_named_time()
    • NamedTimer.get_named_count()
    • NamedTimer.get_named_pace()
    • NamedTimer.get_named_speed()
    • NamedTimer.named_time
    • NamedTimer.named_count
    • NamedTimer.named_pace
    • NamedTimer.named_speed
  • ParallelTimer
    • ParallelTimer.__init__()
    • ParallelTimer.add()
    • ParallelTimer.clear()
    • ParallelTimer.to_str()
    • ParallelTimer.names
    • ParallelTimer.count
    • ParallelTimer.get_named_time()
    • ParallelTimer.get_named_count()
    • ParallelTimer.get_named_pace()
    • ParallelTimer.get_named_speed()
    • ParallelTimer.named_time
    • ParallelTimer.named_count
    • ParallelTimer.named_pace
    • ParallelTimer.named_speed
  • R2_score()
  • RMSE_score()
  • Timer
    • Timer.__init__()
    • Timer.add()
    • Timer.clear()
    • Timer.to_str()
    • Timer.time
    • Timer.count
    • Timer.pace
    • Timer.speed
    • Timer.time_str()
    • Timer.count_str()
    • Timer.pace_str()
    • Timer.speed_str()
    • Timer.to_dict()
    • Timer.from_dict()
  • add_minus_flags()
  • add_negation_flags()
  • adjust_text()
  • classproperty
    • classproperty.__init__()
  • clear_svg()
  • get_fig()
  • init_logger()
  • load_font()
  • log_exception()
  • merge_axes()
  • plotOD()
  • plot_resilience()
  • render_markdown()
  • render_python()
  • sMAPE_score()
  • seed_all()
  • setup_lazy_imports()
  • softmax()
  • tag2ansi()
  • use_chinese_font()
  • Subpackages
    • nd2py.utils.nn package
      • setup_lazy_imports()
      • Submodules
      • nd2py.utils.nn.gnn module
      • nd2py.utils.nn.positional_encoding module
  • Submodules
  • nd2py.utils.attr_dict module
    • AttrDict
      • AttrDict.__init__()
      • AttrDict.load_yaml()
      • AttrDict.load_yaml_str()
  • nd2py.utils.auto_gpu module
    • AutoGPU
      • AutoGPU.__init__()
      • AutoGPU.update_free_memory()
      • AutoGPU.choice_gpu()
      • AutoGPU.query_free_memory()
  • nd2py.utils.classproperty module
    • classproperty
      • classproperty.__init__()
  • nd2py.utils.factory module
    • FactoryMixin
      • FactoryMixin.MODEL_DICT
      • FactoryMixin.register_model()
      • FactoryMixin.create()
  • nd2py.utils.fix_parser module
    • add_minus_flags()
    • add_negation_flags()
  • nd2py.utils.lazy_loader module
    • setup_lazy_imports()
  • nd2py.utils.log_exception module
    • log_exception()
  • nd2py.utils.logger module
    • init_logger()
  • nd2py.utils.metrics module
    • R2_score()
    • RMSE_score()
    • sMAPE_score()
    • MAPE_score()
    • MAE_score()
  • nd2py.utils.plot module
    • get_fig()
    • plot_resilience()
    • EqualizeNormalize
      • EqualizeNormalize.__init__()
      • EqualizeNormalize.inverse()
    • plotOD()
    • clear_svg()
    • load_font()
    • adjust_text()
    • use_chinese_font()
    • merge_axes()
  • nd2py.utils.render_markdown module
    • render_markdown()
  • nd2py.utils.render_python module
    • render_python()
  • nd2py.utils.tag2ansi module
    • tag2ansi()
  • nd2py.utils.timing module
    • Timer
      • Timer.__init__()
      • Timer.add()
      • Timer.clear()
      • Timer.to_str()
      • Timer.time
      • Timer.count
      • Timer.pace
      • Timer.speed
      • Timer.time_str()
      • Timer.count_str()
      • Timer.pace_str()
      • Timer.speed_str()
      • Timer.to_dict()
      • Timer.from_dict()
    • NamedTimer
      • NamedTimer.__init__()
      • NamedTimer.add()
      • NamedTimer.clear()
      • NamedTimer.to_str()
      • NamedTimer.names
      • NamedTimer.time
      • NamedTimer.count
      • NamedTimer.get_named_time()
      • NamedTimer.get_named_count()
      • NamedTimer.get_named_pace()
      • NamedTimer.get_named_speed()
      • NamedTimer.named_time
      • NamedTimer.named_count
      • NamedTimer.named_pace
      • NamedTimer.named_speed
    • ParallelTimer
      • ParallelTimer.__init__()
      • ParallelTimer.add()
      • ParallelTimer.clear()
      • ParallelTimer.to_str()
      • ParallelTimer.names
      • ParallelTimer.count
      • ParallelTimer.get_named_time()
      • ParallelTimer.get_named_count()
      • ParallelTimer.get_named_pace()
      • ParallelTimer.get_named_speed()
      • ParallelTimer.named_time
      • ParallelTimer.named_count
      • ParallelTimer.named_pace
      • ParallelTimer.named_speed
  • nd2py.utils.utils module
    • softmax()
    • seed_all()