minimizesolve 1.0__py3-none-any.whl

miso/codewriter.py

@@ -0,0 +1,267 @@
+import os
+from math import nextafter, inf
+from sympy.printing.cxx import CXX11CodePrinter
+from sympy import S, Float, Rational, Function
+from .poly import is_miso_poly
+
+# Singleton functions used as placeholders in inclusion/sample expressions
+inclusion_func = Function('MiSoInclusion', real=True)
+sample_func = Function('MiSoSample', real=True)
+
+# Special C++ math functions not natively supported by SymPy
+sinpi   = Function('sinpi')
+cospi   = Function('cospi')
+tanpi   = Function('tanpi')
+asinpi  = Function('asinpi')
+acospi  = Function('acospi')
+atanpi  = Function('atanpi')
+exp2    = Function('exp2')
+exp10   = Function('exp10')
+expm1   = Function('expm1')
+exp2m1  = Function('exp2m1')
+exp10m1 = Function('exp10m1')
+log2    = Function('log2')
+log10   = Function('log10')
+log1p   = Function('log1p')
+log2p1  = Function('log2p1')
+log10p1 = Function('log10p1')
+cbrt    = Function('cbrt')
+rsqrt   = Function('rsqrt')
+hypot   = Function('hypot')
+
+
+def replace_special_func(expr):
+	"""Replace expression patterns with specialized C++ math functions.
+
+	Bottom-up traversal: processes children first, then matches at each node.
+	Recognized patterns:
+	    sin(pi*x) -> sinpi(x),  asin(x)/pi -> asinpi(x),  etc.
+	    2**x -> exp2(x),  exp(x)-1 -> expm1(x),  2**x-1 -> exp2m1(x),  etc.
+	    log(x)/log(2) -> log2(x),  log(1+x) -> log1p(x),  log(1+x)/log(2) -> log2p1(x),  etc.
+	    x**(1/3) -> cbrt(x),  x**(-1/2) -> rsqrt(x),  sqrt(x²+y²) -> hypot(x,y)
+	"""
+	from sympy import (pi, sin, cos, tan, asin, acos, atan, exp, log, Add)
+
+	trig_pi = {sin: sinpi, cos: cospi, tan: tanpi}
+	atrig_pi = {asin: asinpi, acos: acospi, atan: atanpi}
+	inv_log2, inv_log10 = 1/log(S(2)), 1/log(S(10))
+	inv_pi = 1/pi
+
+	def _walk(node):
+		if not node.args:
+			return node
+		if is_miso_poly(node):
+			return node
+
+		# Bottom-up: children first
+		new_args = tuple(_walk(a) for a in node.args)
+		if any(a is not b for a, b in zip(new_args, node.args)):
+			node = node.func(*new_args)
+
+		# trig(pi*x) -> trigpi(x)
+		if node.func in trig_pi:
+			c = node.args[0].as_coefficient(pi)
+			if c is not None:
+				return trig_pi[node.func](c)
+
+		# Pow patterns
+		if node.is_Pow:
+			base, e = node.as_base_exp()
+			if e == Rational(1, 3):
+				return cbrt(base)
+			if e == Rational(-1, 2):
+				return rsqrt(base)
+			if e == S.Half and base.is_Add and len(base.args) == 2:
+				a, b = base.args
+				if a.is_Pow and a.exp == 2 and b.is_Pow and b.exp == 2:
+					return hypot(a.base, b.base)
+			if base == S(2) and not e.is_Number:
+				return exp2(e)
+			if base == S(10) and not e.is_Number:
+				return exp10(e)
+
+		# log(1+x) -> log1p(x)
+		if isinstance(node, log) and len(node.args) == 1:
+			arg = node.args[0]
+			if arg.is_Add and S.One in arg.args:
+				return log1p(arg - 1)
+
+		# Mul: atrig/pi, log/log(base)
+		if node.is_Mul:
+			r = node.as_coefficient(inv_pi)
+			if r is not None and r.func in atrig_pi:
+				return atrig_pi[r.func](*r.args)
+			for inv_logb, f_log, f_logp1 in [
+				(inv_log2, log2, log2p1), (inv_log10, log10, log10p1)
+			]:
+				r = node.as_coefficient(inv_logb)
+				if r is not None:
+					if r.func == log1p:
+						return f_logp1(r.args[0])
+					if isinstance(r, log):
+						a = r.args[0]
+						if a.is_Add and S.One in a.args:
+							return f_logp1(a - 1)
+						return f_log(a)
+
+		# Add: f(x) - 1 -> fm1(x)
+		if node.is_Add and S.NegativeOne in node.args:
+			others = [a for a in node.args if a != S.NegativeOne]
+			for i, a in enumerate(others):
+				repl = None
+				if isinstance(a, exp):
+					repl = expm1(a.args[0])
+				elif a.func == exp2:
+					repl = exp2m1(a.args[0])
+				elif a.func == exp10:
+					repl = exp10m1(a.args[0])
+				if repl is not None:
+					return Add(repl, *others[:i], *others[i+1:])
+
+		return node
+
+	return _walk(expr)
+
+
+class CodeWriter:
+	''' Manages a C++ source file '''
+
+	class SymPyFormatter(CXX11CodePrinter):
+		''' Formats SymPy expressions for C++ '''
+
+		def _print_Rational(self, expr):
+			fp = float(expr)
+			if fp < expr:
+				fpu = nextafter(fp, +inf)
+				return f'_R({fp}, {fpu})'
+			elif fp > expr:
+				fpl = nextafter(fp, -inf)
+				return f'_R({fpl}, {fp})'
+			else:
+				return f'{fp}'
+
+		def _print_Pow(self, expr):
+			base, exp = expr.as_base_exp()
+			if exp.is_integer:
+				return f"pown({self._print(base)}, {int(exp)})"
+			if exp == Rational(1, 2):
+				return f"sqrt({self._print(base)})"
+			if exp == Rational(-1, 2):
+				return f"rsqrt({self._print(base)})"
+			return f"pow({self._print(base)}, {self._print(exp)})"
+
+		def _print_Abs(self, expr):
+			return f'abs({self._print(expr.args[0])})'
+
+		def _print_Max(self, expr):
+			return '(' + '|'.join(self._print(a) for a in expr.args) + ')'
+
+		def _print_Min(self, expr):
+			return '(' + '&'.join(self._print(a) for a in expr.args) + ')'
+
+		# Standard math functions: emit unqualified so ADL finds tight:: overloads
+		def _unary(self, expr): return f'{type(expr).__name__}({self._print(expr.args[0])})'
+		_print_sin = _print_cos = _print_tan = _print_asin = _print_acos = _print_atan = \
+		_print_sinh = _print_cosh = _print_tanh = _print_asinh = _print_acosh = _print_atanh = \
+		_print_exp = _print_log = _print_erf = _unary
+
+		def _print_atan2(self, expr):
+			return f'atan2({self._print(expr.args[0])}, {self._print(expr.args[1])})'
+
+		_special_funcs = {f.__name__ for f in (
+			sinpi, cospi, tanpi, asinpi, acospi, atanpi,
+			exp2, exp10, expm1, exp2m1, exp10m1,
+			log2, log10, log1p, log2p1, log10p1,
+			cbrt, rsqrt, hypot,
+		)} | {'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2',
+		      'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+		      'exp', 'log', 'sqrt', 'erf'}
+
+		def _print_Function(self, expr):
+			if expr.func.__name__ == 'MiSoInclusion':
+				return f'{self._print(expr.args[0])}.inclusion()'
+			if expr.func.__name__ == 'MiSoSample':
+				name = self._print(expr.args[0])
+				indices = ','.join(str(int(a)) for a in expr.args[1:])
+				return f'{name}.sample<{indices}>()'
+			if expr.func.__name__ in self._special_funcs:
+				args = ', '.join(self._print(a) for a in expr.args)
+				return f'{expr.func.__name__}({args})'
+			return super()._print_Function(expr)
+
+	def __init__(self, filepath, overwrite=True, pragma_regions=True):
+		''' Open and possibly create the managed file '''
+		self.filepath = filepath
+		if overwrite or not os.path.exists(filepath):
+			self.file = open(filepath, 'w')
+		else:
+			raise FileExistsError(f'{filepath} already exists')
+		self.tablv = 0
+		self.formatter = self.SymPyFormatter()
+		self.newline = True
+		self.pragma_regions = pragma_regions
+
+	def __enter__(self): return self
+	def __exit__(self, exc_type, exc_val, ex_tb): self.close()
+	def __str__(self): return f'File {self.filepath}'
+
+	def close(self):
+		self.file.close()
+
+	def tabin(self):
+		self.tablv += 1
+		return self
+
+	def tabout(self):
+		self.tablv -= 1
+		assert self.tablv >= 0
+		return self
+
+	def write(self, l='', newline=True):
+		''' Write a single line with indent '''
+		def brackets_imbalance(l):
+			d = 0
+			for c in l:
+				if c in '{[(': d += 1
+				elif c in '}])': d -= 1
+			return d
+
+		if len(l) > 0:
+			diff = brackets_imbalance(l)
+			if diff < 0: self.tabout()
+			if self.newline:
+				for i in range(self.tablv): self.file.write('\t')
+			if diff > 0: self.tabin()
+			self.file.write(l)
+		if newline: self.file.write('\n')
+		self.newline = newline
+		return self
+
+	def joint_write(self, separator, lines):
+		''' Write all lines, adding separator to each except the last '''
+		if len(lines) == 0: return self
+		for l in lines[:-1]:
+			self.write(l + separator)
+		self.write(lines[-1])
+		return self
+
+	def region(self, name):
+		if self.pragma_regions:
+			self.write(f'#pragma region {name}')
+		else:
+			self.write(f'/* {name} */')
+
+	def endregion(self):
+		if self.pragma_regions:
+			self.write(f'#pragma endregion')
+
+	def format(self, expr):
+		''' Return a formatted SymPy expression as a C++ string '''
+		return self.formatter.doprint(expr)
+
+	def w_assign(self, lhs, rhs, declare=''):
+		''' Write an assignment using the SymPy formatter '''
+		s = self.formatter.doprint(rhs, lhs)
+		if declare: self.write(f'{declare} {s}')
+		else: self.write(s)
+		return self

miso/domain.py

@@ -0,0 +1,398 @@
+from sympy import symbols, Rational, Matrix, numbered_symbols, Symbol, Add, Mul, Pow, diff, factorial
+from sympy.polys.polyfuncs import interpolate
+from sympy.polys.matrices import DomainMatrix
+from sympy import QQ
+from itertools import product, chain, starmap
+from math import prod
+
+from .poly import make_poly, is_miso_poly
+from .codewriter import inclusion_func, sample_func
+from .subdivision import MiSoSubdivision, subdivision, combine_subdiv
+from .logger import MiSoLogger
+
+
+def _degree_in_vars(expr, variables):
+	'''Max total degree of expr in the given variables, via tree walk (no expansion).'''
+	vs = set(variables)
+
+	class DegExpr:
+		def __init__(self, d=1): self.deg = d
+		def __add__(self, o): return DegExpr(max(self.deg, o.deg)) if isinstance(o, DegExpr) else self
+		def __radd__(self, o): return self + o
+		def __mul__(self, o): return DegExpr(self.deg + o.deg) if isinstance(o, DegExpr) else self
+		def __rmul__(self, o): return self * o
+		def __pow__(self, o): return DegExpr(self.deg * int(o))
+
+	def propagate(e):
+		if e.func == Symbol:
+			return DegExpr(1) if e in vs else e
+		children = tuple(propagate(x) for x in e.args)
+		if e.func == Add:
+			return sum(children)
+		elif e.func == Mul:
+			return prod(children)
+		elif e.func == Pow:
+			return children[0] ** children[1]
+		return e
+
+	d = propagate(expr)
+	return d.deg if isinstance(d, DegExpr) else 0
+
+
+def _build_l2b(B, variables, E):
+	'''Build Bernstein evaluation matrix as DomainMatrix over QQ and return its inverse.'''
+	N = len(B)
+	rows = [[QQ.from_sympy(b.eval(dict(zip(variables, e))).as_expr()) for b in B] for e in E]
+	return DomainMatrix(rows, (N, N), QQ).inv()
+
+
+def _compute_b2b(l2b, B, variables, E, trans, bv_mat):
+	'''Compute a single B2B conversion matrix (picklable for parallel use).'''
+	ET = tuple(
+		tuple(
+			(trans @ Matrix(list(e) + [Rational(1)]))[i, 0]
+			for i in range(trans.rows)
+		)
+		for e in E
+	)
+	N = len(B)
+	rows = [[QQ.from_sympy(b.eval(dict(zip(variables, e))).as_expr()) for b in B] for e in ET]
+	MT = DomainMatrix(rows, (N, N), QQ)
+	b2b = l2b * MT  # DomainMatrix over QQ
+	bv = list(bv_mat.flat())
+	bv_dm = DomainMatrix([[v] for v in bv], (N, 1), QQ)
+	result = b2b * bv_dm
+	return result.to_list_flat()
+
+
+def _sig_name(simplex_degs):
+	'''Format signature as e.g. "2p3" or "2p1_1p1" '''
+	return '_'.join(f'{dim}p{deg}' for dim, deg in simplex_degs)
+
+def _all_compositions(n, total):
+	if n == 1:
+		yield (total,)
+		return
+	for i in range(total + 1):
+		for rest in _all_compositions(n - 1, total - i):
+			yield (i,) + rest
+
+
+class MiSoDomain:
+	_map_counter = 0
+
+	def __init__(self, *variables):
+		ms = MiSoDomain.MiSoSimplex
+		simplices = (v if isinstance(v, ms) else ms(v) for v in variables)
+		self.simplices = tuple(filter(lambda s: not s.is_empty, simplices))
+		self._basis_cache = {}
+
+	@property
+	def variables(self):
+		return tuple(v for s in self.simplices for v in s.variables)
+
+	@property
+	def is_empty(self): return len(self.variables) == 0
+
+	@property
+	def dimension(self):
+		return sum(s.dimension for s in self.simplices)
+
+	@property
+	def num_vertices(self):
+		return prod(s.num_vertices for s in self.simplices)
+
+	@property
+	def vertices(self):
+		'''
+		All vertices of the domain as tuples of coordinate values.
+		'''
+		factors = [s.vertices for s in self.simplices]
+		return list(map(lambda x: tuple(chain(*x)), product(*factors)))
+
+	@property
+	def default_subdivision(self):
+		sub = tuple(s.default_subdivision for s in self.simplices)
+		prod_mats = tuple(starmap(combine_subdiv, product(*sub)))
+		return MiSoSubdivision(*prod_mats)
+
+	def subdivision(self, *simplex_domains):
+		'''Bisect only the listed simplex domains; identity on the rest.
+		Each argument should be a MiSoDomain whose variables match one of the simplices.'''
+		target_vars = set()
+		for sd in simplex_domains:
+			target_vars.update(sd.variables)
+		sub = []
+		for s in self.simplices:
+			if any(v in target_vars for v in s.variables):
+				sub.append(s.default_subdivision)
+			else:
+				# Identity: single matrix that maps domain to itself
+				d = s.dimension
+				identity = subdivision(
+					*(tuple(int(i == j) for j in range(d)) for i in range(d + 1))
+				)
+				sub.append((identity,))
+		prod_mats = tuple(starmap(combine_subdiv, product(*sub)))
+		return MiSoSubdivision(*prod_mats)
+
+	def __getitem__(self, i): return self.variables[i]
+
+	def __str__(self):
+		return 'Domain(' + str(', '.join(str(s.variables) for s in self.simplices)) + ')'
+
+	def __mul__(self, o):
+		V = set(self.variables)
+		OV = set(o.variables)
+		if not V.isdisjoint(OV):
+			raise ValueError('Domains cannot share variables')
+		return MiSoDomain(*self.simplices, *o.simplices)
+
+	@property
+	def signature(self):
+		return tuple(len(s.variables) for s in self.simplices)
+
+	def subdomain(self, expr):
+		'''Return the smallest subdomain that can represent the expression.'''
+		return MiSoDomain(*(s.subdomain(expr) for s in self.simplices))
+
+	def degs(self, expr):
+		'''Return the list of degrees (one per simplex) needed to represent the expression.'''
+		res = []
+		for s in self.simplices:
+			d = _degree_in_vars(expr, s.variables)
+			if d > 0:
+				res.append(d)
+		return tuple(res)
+
+	def parameters(self, *expr):
+		'''
+		Get free parameters (arguments) from a list of expressions —
+		all free symbols not in domain variables.
+		'''
+		fs = set.union(*(ex.free_symbols for ex in expr))
+		if any(not s.is_Symbol for s in fs):
+			raise ValueError(f'{fs} contains non-Symbols')
+		return fs.difference(self.variables)
+
+	def _product_basis(self, simplexf, *degs):
+		assert len(self.simplices) == len(degs), \
+			'Degrees/simplices list size mismatch'
+		factors = tuple(simplexf(s, d) for s, d in zip(self.simplices, degs))
+		return tuple(map(
+			lambda p: p.as_poly(self.variables),
+			map(prod, product(*factors))
+		))
+
+	def bernstein(self, *degs):
+		key = ('bernstein', degs)
+		if key not in self._basis_cache:
+			self._basis_cache[key] = self._product_basis(lambda s, d: s.bernstein(d), *degs)
+		return self._basis_cache[key]
+
+	def lagrange(self, *degs):
+		key = ('lagrange', degs)
+		if key not in self._basis_cache:
+			self._basis_cache[key] = self._product_basis(lambda s, d: s.lagrange(d), *degs)
+		return self._basis_cache[key]
+
+	def monomial(self, *degs):
+		key = ('monomial', degs)
+		if key not in self._basis_cache:
+			self._basis_cache[key] = self._product_basis(lambda s, d: s.monomial(d), *degs)
+		return self._basis_cache[key]
+
+	def eval_points(self, *degs):
+		assert len(self.simplices) == len(degs), \
+			'Degrees/simplices list size mismatch'
+		factors = tuple(s.eval_points(d) for s, d in zip(self.simplices, degs))
+		return tuple(map(lambda x: tuple(chain(*x)), product(*factors)))
+
+	def poly_map(self, deg, basis, codomain_dim=1, name=None, output_miso_poly=True):
+		'''
+		Create a polynomial map over this domain.
+
+		Generates control point symbols and returns a Matrix of `codomain_dim`
+		MiSoPoly (or plain SymPy) expressions — one per output coordinate.
+
+		Arguments:
+		  deg              -- polynomial degree (int or tuple, one per simplex)
+		  basis            -- Basis.LAGRANGE, Basis.BERNSTEIN, or Basis.MONOMIAL
+		  codomain_dim     -- number of output coordinates (default 1)
+		  name             -- base name for control point symbols (auto-generated if None)
+		  output_miso_poly -- wrap output in MiSoPoly if True (default True)
+		'''
+		degs = (deg,) * len(self.simplices) if isinstance(deg, int) else tuple(deg)
+
+		if basis == Basis.LAGRANGE:
+			basis_polys = self.lagrange(*degs)
+		elif basis == Basis.BERNSTEIN:
+			basis_polys = self.bernstein(*degs)
+		elif basis == Basis.MONOMIAL:
+			basis_polys = self.monomial(*degs)
+		else:
+			raise ValueError(f'Unknown basis: {basis}')
+
+		N = len(basis_polys)
+
+		if name is None:
+			name = f'p{MiSoDomain._map_counter}'
+			MiSoDomain._map_counter += 1
+
+		coord_names = 'xyzw'
+		result = []
+		for d in range(codomain_dim):
+			cname = coord_names[d] if d < len(coord_names) else f'x{d}_'
+			cps = tuple(Symbol(f'{name}{cname}[{i}]') for i in range(N))
+			poly_expr = sum(cp * b.as_expr() for cp, b in zip(cps, basis_polys))
+			result.append(make_poly(poly_expr) if output_miso_poly else poly_expr)
+
+		return Matrix(result)
+
+	# Alias for backward compatibility
+	geo_map = poly_map
+
+	###########################################################
+
+	class MiSoSimplex:
+		def __init__(self, *names):
+			if not names:
+				self._variables = tuple()
+			elif all(isinstance(n, str) for n in names):
+				vs = symbols(*names, real=True, positive=True)
+				if isinstance(vs, (list, tuple)):
+					self._variables = tuple(vs)
+				elif vs.is_Symbol:
+					self._variables = (vs,)
+				else:
+					self._variables = tuple(vs)
+			elif all(n.is_Symbol for n in names):
+				self._variables = tuple(names)
+			else:
+				raise ValueError('Variable names must be all strings or symbols')
+
+		@property
+		def variables(self): return self._variables
+
+		@property
+		def is_empty(self): return len(self.variables) == 0
+
+		@property
+		def dimension(self): return len(self.variables)
+
+		@property
+		def num_vertices(self): return self.dimension + 1
+
+		@property
+		def vertices(self):
+			return [tuple(int(x) for x in e) for e in self.eval_points(1)]
+
+		@property
+		def default_subdivision(self):
+			H = Rational(1, 2)
+			D = self.dimension
+			if D == 1:
+				return MiSoSubdivision(
+					subdivision((0,), (H,)),
+					subdivision((H,), (1,)),
+				)
+			elif D == 2:
+				return MiSoSubdivision(
+					subdivision((0, 0), (H, 0), (0, H)),
+					subdivision((H, 0), (1, 0), (H, H)),
+					subdivision((0, H), (H, H), (0, 1)),
+					subdivision((H, H), (0, H), (H, 0)),
+				)
+			elif D == 3:
+				return MiSoSubdivision(
+					subdivision((0, 0, 0), (H, 0, 0), (0, H, 0), (0, 0, H)),
+					subdivision((H, 0, 0), (1, 0, 0), (H, H, 0), (H, 0, H)),
+					subdivision((0, H, 0), (H, H, 0), (0, 1, 0), (0, H, H)),
+					subdivision((0, 0, H), (H, 0, H), (0, H, H), (0, 0, 1)),
+					subdivision((H, 0, 0), (0, H, 0), (0, 0, H), (H, 0, H)),
+					subdivision((H, 0, 0), (0, H, 0), (H, H, 0), (H, 0, H)),
+					subdivision((0, H, 0), (0, 0, H), (H, 0, H), (0, H, H)),
+					subdivision((0, H, 0), (H, H, 0), (H, 0, H), (0, H, H)),
+				)
+			else:
+				raise NotImplementedError(f'Default subdivision not implemented for simplex dimension {D}, supply your own')
+
+		def subdomain(self, expr):
+			fs = expr.free_symbols
+			return MiSoDomain.MiSoSimplex(*(v for v in self.variables if v in fs))
+
+		def bernstein(self, deg):
+			vs = self.variables + (1 - sum(self.variables),)
+			n = len(vs)
+
+			def bp(combo_coeff):
+				combo, coeff = combo_coeff
+				return (coeff * prod(v ** k for v, k in zip(vs, combo))).as_poly(self.variables)
+
+			return tuple(map(bp, _all_compositions_with_coeff(n, deg)))
+
+		def lagrange(self, deg):
+			vs = self.variables + (1 - sum(self.variables),)
+
+			def lp(combo):
+				return prod(
+					interpolate(
+						{Rational(x, deg): int(x == n) for x in range(n + 1)}, v)
+					for v, n in zip(vs, combo)
+				).as_poly(self.variables)
+
+			return tuple(map(lp, _all_compositions(len(vs), deg)))
+
+		def monomial(self, deg):
+			vs = self.variables
+			k = len(vs)
+			result = []
+			for total in range(deg + 1):
+				for combo in _all_compositions(k, total):
+					mono = prod(v**e for v, e in zip(vs, combo))
+					result.append(mono.as_poly(vs))
+			return tuple(result)
+
+		def eval_points(self, deg):
+			lv = len(self.variables)
+			D = max(int(deg), 1)
+			return tuple(
+				tuple(Rational(n, D) for n in combo[:lv])
+				for combo in _all_compositions(1 + lv, deg)
+			)
+
+
+def _all_compositions(n, total):
+	if n == 1:
+		yield (total,)
+		return
+	for i in range(total + 1):
+		for rest in _all_compositions(n - 1, total - i):
+			yield (i,) + rest
+
+
+def _all_compositions_with_coeff(n, deg):
+	from math import factorial
+	def multinomial(lst):
+		s = sum(lst)
+		r = factorial(s)
+		for x in lst:
+			r //= factorial(x)
+		return r
+	for combo in _all_compositions(n, deg):
+		yield combo, multinomial(combo)
+
+
+###########################################################
+# Basis enum and geo_map helper
+###########################################################
+
+class Basis:
+	LAGRANGE = 'lagrange'
+	BERNSTEIN = 'bernstein'
+	MONOMIAL = 'monomial'
+
+
+def geo_map(domain, deg, basis, embed_dim=1, name=None, poly=True):
+	'''Alias for domain.poly_map() as a free function (backward-compatible signature).'''
+	return domain.poly_map(deg, basis, codomain_dim=embed_dim, name=name, output_miso_poly=poly)