minimizesolve 1.0__py3-none-any.whl

minimizesolve-1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: minimizesolve
+Version: 1.0
+Requires-Python: >=3.7
+Requires-Dist: sympy

minimizesolve-1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+miso/__init__.py,sha256=7h-MClkP2Rffy-TUZkP0Q_5nS2E5KKliY_ssGqrSwQY,837
+miso/codegen.py,sha256=LJHZGiULHn3v__W1IehSKGJ1-tThqVuFblDMNf_gLHE,16840
+miso/codewriter.py,sha256=XPePIIIGkDQGLEMqlvboiq4MhWdciCb9QELbnmoJn78,8066
+miso/domain.py,sha256=OV3uzG5ULUZLwkXXgNS5sTtwE-JkwX7I3eO2Y9N2MDU,12368
+miso/generate.py,sha256=mOhyfabDRPF6gQyz0Wmfh1z9FJd23jWsBiFsu2DmVjM,8776
+miso/logger.py,sha256=UzPGDq4-BJ-45DN47uB_fUo110YNpcTglIk7eduTfk8,1173
+miso/poly.py,sha256=uNtsNDiz0JkSdCN_RxeTy2swygVEjBLkTfC2AiUvCro,1546
+miso/subdivision.py,sha256=wzD1jeSrctyQ0s29FzK-rRynwFIQ-LEHnqb2kjXsN3k,2045
+minimizesolve-1.0.dist-info/METADATA,sha256=Ar-6UeUPqcYX0fcQzBKH9_Cl9gYySnr2yzs-yQfni4Q,99
+minimizesolve-1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+minimizesolve-1.0.dist-info/top_level.txt,sha256=iwv6V2F286f_4aS4Rq0XaYXFfE_w0LTpI9J-DycHZig,5
+minimizesolve-1.0.dist-info/RECORD,,

minimizesolve-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

minimizesolve-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+miso

miso/__init__.py

@@ -0,0 +1,23 @@
+MISO_VNUM = (1, 0)
+MISO_VERSION = '.'.join(map(str, MISO_VNUM))
+
+import sys
+MIN_PYTHON_VERSION = (3, 7)
+if sys.version_info < MIN_PYTHON_VERSION:
+	raise RuntimeError(
+		f'Python ({sys.version_info}) is not supported. '
+		f'MiSo {MISO_VERSION} requires Python '
+		f'{".".join(map(str, MIN_PYTHON_VERSION))} or higher.'
+	)
+
+from .domain import MiSoDomain, geo_map, Basis
+from .generate import generate
+from .poly import make_poly, unmake_poly, collapse, expand, is_miso_poly, tree
+from .subdivision import MiSoSubdivision, subdivision, combine_subdiv
+from .codewriter import (CodeWriter, inclusion_func, replace_special_func,
+	sinpi, cospi, tanpi, asinpi, acospi, atanpi,
+	exp2, exp10, expm1, exp2m1, exp10m1,
+	log2, log10, log1p, log2p1, log10p1,
+	cbrt, rsqrt, hypot)
+from .codegen import MiSoCodeGenerator
+from .logger import MiSoLogger

miso/codegen.py

@@ -0,0 +1,503 @@
+import os
+from sympy import cse, numbered_symbols
+from .codewriter import CodeWriter, inclusion_func
+from .logger import MiSoLogger
+
+NAMESPACE = 'miso'
+TARGET_NAME = NAMESPACE
+
+
+def _group_args(syms):
+	'''
+	Group symbols into named vectors or scalars.
+	Symbols named 'base[i]' are grouped into a vector (base, [sym0, sym1, ...]).
+	Indices must be contiguous from 0; raises ValueError otherwise.
+	Symbols without '[' are treated as scalars: (name, [sym]).
+	Groups are sorted alphabetically by base name.
+	'''
+	vectors = {}
+	scalars = []
+	for s in syms:
+		n = s.name
+		if '[' in n:
+			base, rest = n.rsplit('[', 1)
+			idx = int(rest.rstrip(']'))
+			vectors.setdefault(base, {})[idx] = s
+		else:
+			scalars.append(s)
+
+	result = []
+	for base in sorted(vectors):
+		d = vectors[base]
+		count = len(d)
+		for i in range(count):
+			if i not in d:
+				raise ValueError(f'Missing index {i} in vector argument {base!r}')
+		result.append((base, [d[i] for i in range(count)]))
+
+	for s in sorted(scalars, key=lambda s: s.name):
+		result.append((s.name, [s]))
+
+	return result
+
+
+def _args_decl(grouped):
+	'''Declaration strings for grouped args: RealVector<N> for vectors, Real for scalars.'''
+	parts = []
+	for name, syms in grouped:
+		if '[' in syms[0].name:
+			parts.append(f'const RealVector<{len(syms)}> &{name}')
+		else:
+			parts.append(f'const Real {name}')
+	return parts
+
+
+class MiSoCodeGenerator:
+	''' Manages C++ code generation for a MiSo problem class '''
+
+	def __init__(self, source_dir, class_name, domain, clean=True):
+		self.class_name = class_name
+		self.domain = domain
+		self.directory = os.path.join(source_dir, class_name)
+		self.added_cpp = []
+		self.added_sig = []
+		self.log = MiSoLogger.get()
+
+		if not os.path.exists(self.directory):
+			os.makedirs(self.directory)
+		elif clean:
+			for file_name in os.listdir(self.directory):
+				file_path = os.path.join(self.directory, file_name)
+				if os.path.isfile(file_path):
+					os.remove(file_path)
+
+	def _cpp_path(self, name):
+		return os.path.join(self.directory, name + '.cpp')
+
+	def _write_with_cse(self, f, exprs):
+		'''Write expressions with CSE temporaries extraction.'''
+		replacements, reduced = cse(exprs, symbols=numbered_symbols('_t'))
+		if replacements:
+			f.region('Temporaries')
+			for sym, val in replacements:
+				f.write(f'const Real {sym} = {f.format(val)};')
+			f.endregion()
+		f.region('Expressions')
+		f.write('return {')
+		for e in reduced:
+			f.write(f.format(e) + ',')
+		f.write('};')
+		f.endregion()
+
+	def write_cl(self, member_name, lag_exprs, poly_args):
+		'''
+		Write CL_<member_name>.cpp — evaluates polynomial at Lagrange points.
+		'''
+		func_name = f'CL_{member_name}'
+		filename = func_name + '.cpp'
+		self.log.info(f'Writing {filename}')
+		self.added_cpp.append(filename)
+		N = len(lag_exprs)
+
+		grouped = _group_args(poly_args)
+		inputs_str = ', '.join(_args_decl(grouped))
+
+		with CodeWriter(self._cpp_path(func_name)) as f:
+			f.write(f'#include "{self.class_name}.hpp"')
+			f.write(f'namespace {NAMESPACE} {{')
+			sig = f'RealVector<{N}> {self.class_name}::{func_name}({inputs_str})'
+			f.write(sig + ' {')
+			self._write_with_cse(f, lag_exprs)
+			f.write('}')
+			f.write('}')
+
+		self.added_sig.append(f'static RealVector<{N}> {func_name}({inputs_str});')
+
+	def write_cb(self, member_name, cb_exprs, poly_args):
+		'''
+		Write CB_<member_name>.cpp — combined Lagrange-to-Bernstein conversion.
+		'''
+		func_name = f'CB_{member_name}'
+		filename = func_name + '.cpp'
+		self.log.info(f'Writing {filename}')
+		self.added_cpp.append(filename)
+		N = len(cb_exprs)
+
+		grouped = _group_args(poly_args)
+		inputs_str = ', '.join(_args_decl(grouped))
+
+		with CodeWriter(self._cpp_path(func_name)) as f:
+			f.write(f'#include "{self.class_name}.hpp"')
+			f.write(f'namespace {NAMESPACE} {{')
+			sig = f'RealVector<{N}> {self.class_name}::{func_name}({inputs_str})'
+			f.write(sig + ' {')
+			self._write_with_cse(f, cb_exprs)
+			f.write('}')
+			f.write('}')
+
+		self.added_sig.append(f'static RealVector<{N}> {func_name}({inputs_str});')
+
+	def write_lb(self, sig_name, lb_exprs, N):
+		'''
+		Write LB_<sig>.cpp — Lagrange to Bernstein conversion.
+		Takes const RealVector<N> &_l as input.
+		'''
+		func_name = f'LB_{sig_name}'
+		filename = func_name + '.cpp'
+		self.log.info(f'Writing {filename}')
+		self.added_cpp.append(filename)
+
+		with CodeWriter(self._cpp_path(func_name)) as f:
+			f.write(f'#include "{self.class_name}.hpp"')
+			f.write(f'namespace {NAMESPACE} {{')
+			f.write(f'RealVector<{N}> {self.class_name}::{func_name}(const RealVector<{N}> &_l) {{')
+			self._write_with_cse(f, lb_exprs)
+			f.write('}')
+			f.write('}')
+
+		self.added_sig.append(f'static RealVector<{N}> {func_name}(const RealVector<{N}> &_l);')
+
+	def write_subdivision(self, sig_name, si, q, b2b_exprs, N):
+		'''
+		Write subdiv_<si>_<sig>_<q>.cpp — B2B subdivision (one file per child).
+		Takes const RealVector<N> &_b as input.
+		'''
+		func_name = f'subdiv_{si}_{sig_name}_{q}'
+		filename = func_name + '.cpp'
+		self.log.info(f'Writing {filename}')
+		self.added_cpp.append(filename)
+
+		with CodeWriter(self._cpp_path(func_name)) as f:
+			f.write(f'#include "{self.class_name}.hpp"')
+			f.write(f'namespace {NAMESPACE} {{')
+			f.write(f'RealVector<{N}> {self.class_name}::{func_name}(const RealVector<{N}> &_b) {{')
+			self._write_with_cse(f, b2b_exprs)
+			f.write('}')
+			f.write('}')
+
+		self.added_sig.append(f'static RealVector<{N}> {func_name}(const RealVector<{N}> &_b);')
+
+	def write_subdivision_combined(self, sig_name, si, all_b2b_exprs, N):
+		'''
+		Write subdiv_<si>_<sig>.cpp — all children in one function with shared CSE.
+		Takes const RealVector<N> &_b, returns std::array<RealVector<N>, Q>.
+		'''
+		Q = len(all_b2b_exprs)
+		func_name = f'subdiv_{si}_{sig_name}'
+		filename = func_name + '.cpp'
+		self.log.info(f'Writing {filename}')
+		self.added_cpp.append(filename)
+
+		flat = [e for exprs in all_b2b_exprs for e in exprs]
+		replacements, reduced = cse(flat, symbols=numbered_symbols('_t'))
+
+		with CodeWriter(self._cpp_path(func_name)) as f:
+			f.write(f'#include "{self.class_name}.hpp"')
+			f.write(f'namespace {NAMESPACE} {{')
+			f.write(f'std::array<RealVector<{N}>, {Q}> {self.class_name}::{func_name}(const RealVector<{N}> &_b) {{')
+			if replacements:
+				f.region('Temporaries')
+				for sym, val in replacements:
+					f.write(f'const Real {sym} = {f.format(val)};')
+				f.endregion()
+			f.region('Expressions')
+			f.write('return {{')
+			for q in range(Q):
+				chunk = reduced[q*N:(q+1)*N]
+				f.write('{')
+				for e in chunk:
+					f.write(f.format(e) + ',')
+				f.write('},')
+			f.write('}};')
+			f.endregion()
+			f.write('}')
+			f.write('}')
+
+		self.added_sig.append(f'static std::array<RealVector<{N}>, {Q}> {func_name}(const RealVector<{N}> &_b);')
+
+	def write_class(self, *, members, var_syms, poly_sizes, member_sigs,
+	                var_sig, inclusions, samples, num_constraints, has_objective,
+	                args, all_subdivisions, conversions_B2B, separate_conversion,
+	                separate_subdivision=False):
+		'''Write <class_name>.cpp and <class_name>.hpp.'''
+		source_name = f'{self.class_name}.cpp'
+		header_name = f'{self.class_name}.hpp'
+		self.log.info(f'Writing {source_name} and {header_name}')
+		self.added_cpp.append(source_name)
+
+		name = self.class_name
+		domain = self.domain
+		dim = domain.dimension
+		num_vertices = domain.num_vertices
+
+		poly_member_names = [str(v) for v in members.values()]
+		var_member_names = [str(v) for v in var_syms.values()]
+		all_member_names = poly_member_names + var_member_names
+
+		# Constructor argument declarations
+		grouped_args = _group_args(args)
+		args_decl = _args_decl(grouped_args)
+
+		# Args that appear directly in inclusion expressions (not via poly members)
+		# must be stored as members so inclusion()/sample() can access them.
+		member_syms = set(members.values()) | set(var_syms.values())
+		raw_arg_syms = {s for inc in inclusions for s in inc.free_symbols
+		                if s in set(args) and s not in member_syms}
+		raw_arg_groups = _group_args(raw_arg_syms)
+
+		# Member initializations
+		poly_init = []
+		for poly, mem_sym in members.items():
+			mname = str(mem_sym)
+			sig = member_sigs[mem_sym]
+			poly_syms = {s for s in poly.free_symbols if s in set(args)}
+			poly_bases = {s.name.rsplit('[', 1)[0] if '[' in s.name else s.name for s in poly_syms}
+			full_poly_syms = {s for s in args if (s.name.rsplit('[', 1)[0] if '[' in s.name else s.name) in poly_bases}
+			call_args = ', '.join(name for name, _ in _group_args(full_poly_syms))
+			if separate_conversion:
+				poly_init.append(f'{mname}(LB_{sig}(CL_{mname}({call_args})))')
+			else:
+				poly_init.append(f'{mname}(CB_{mname}({call_args}))')
+
+		var_init = []
+		for i, (var_sym, vsym) in enumerate(var_syms.items()):
+			vname = str(vsym)
+			coords = [str(v[i]) for v in domain.vertices]
+			var_init.append(f'{vname}{{{", ".join(coords)}}}')
+
+		raw_arg_init = [f'{gname}({gname})' for gname, _ in raw_arg_groups]
+		all_init = raw_arg_init + poly_init + var_init
+
+		# Build mapping: for each strategy and combined subdivision index q,
+		# which per-signature B2B function applies to each member
+		# member_subdiv_mapping[si][mem_sym] = list of projected q indices
+		member_subdiv_mapping = {}
+		for si, subdivs in enumerate(all_subdivisions):
+			member_subdiv_mapping[si] = {}
+			for poly, mem_sym in members.items():
+				subdomain = domain.subdomain(poly)
+				drop = [i for i in range(dim) if domain.variables[i] not in subdomain.variables]
+				proj = subdivs.projection(*drop)
+				member_subdiv_mapping[si][mem_sym] = [proj.mapping(i) for i in range(len(subdivs))]
+
+		##########
+		# SOURCE #
+		##########
+		with CodeWriter(os.path.join(self.directory, source_name)) as f:
+			f.write(f'#include "{header_name}"')
+			f.write(f'namespace {NAMESPACE} {{')
+
+			# Subdivision constructor
+			member_decl = (
+				[f'const RealVector<{poly_sizes[ms]}> &{str(ms)}' for ms in members.values()] +
+				[f'const RealVector<{num_vertices}> &{str(vs)}' for vs in var_syms.values()]
+			)
+			f.write(f'{name}::{name}(const {name} &parent, unsigned q,')
+			f.joint_write(',', member_decl)
+			f.write(') :')
+			f.joint_write(',', [f'{m}({m})' for m in all_member_names])
+			f.write('{ inherit(parent, q); }')
+			f.write()
+
+			# Main constructor
+			if args_decl:
+				f.write(f'{name}::{name}(')
+				f.joint_write(',', args_decl)
+				f.write(') :')
+			else:
+				f.write(f'{name}::{name}() :')
+			f.joint_write(',', all_init)
+			f.write('{')
+			f.write('history = std::make_shared<SubdivHistory>();')
+			f.write('}')
+			f.write()
+
+			# inherit()
+			f.write(f'void {name}::inherit(const {name} &parent, unsigned q) {{')
+			f.write('depth = parent.depth + 1;')
+			f.write('history = std::make_shared<SubdivHistory>(q, parent.history);')
+			for gname, _ in raw_arg_groups:
+				f.write(f'{gname} = parent.{gname};')
+			f.write('}')
+
+			# inclusion()
+			f.write(f'RealInterval {name}::inclusion(unsigned i) const {{')
+			f.write('switch (i) {')
+			for j, inc in enumerate(inclusions):
+				f.write(f'case {j}: return {f.format(inc)};')
+			f.write('default: throw std::logic_error("Undefined inclusion function");')
+			f.write('}')
+			f.write('}')
+
+			# sample(): same structure as inclusion but with .sample<>() calls
+			f.write(f'RealVector<{name}::numVertices> {name}::sample(unsigned i) const {{')
+			f.write('switch (i) {')
+			for j, samp in enumerate(samples):
+				f.write(f'case {j}: return {f.format(samp)};')
+			f.write('default: throw std::logic_error("Undefined sampling function");')
+			f.write('}')
+			f.write('}')
+
+			# split<SI>() explicit specializations
+			for si, subdivs in enumerate(all_subdivisions):
+				num_subs = len(subdivs)
+				f.write(f'template<> std::array<{name}, {name}::schemes[{si}]> {name}::split<{si}>() const {{')
+				if not separate_subdivision:
+					for mem_sym in members.values():
+						mname = str(mem_sym)
+						sig = member_sigs[mem_sym]
+						f.write(f'auto _r_{mname} = subdiv_{si}_{sig}({mname});')
+					for vsym in var_syms.values():
+						vname = str(vsym)
+						f.write(f'auto _r_{vname} = subdiv_{si}_{var_sig}({vname});')
+					f.write('return {')
+					for qi in range(num_subs):
+						child_args = []
+						for mem_sym in members.values():
+							mname = str(mem_sym)
+							pq = member_subdiv_mapping[si][mem_sym][qi]
+							child_args.append(f'_r_{mname}[{pq}]')
+						for vsym in var_syms.values():
+							vname = str(vsym)
+							child_args.append(f'_r_{vname}[{qi}]')
+						f.write(f'{name}{{*this, {qi},')
+						f.joint_write(', ', child_args)
+						f.write('},')
+					f.write('};')
+				else:
+					f.write('return {')
+					for qi in range(num_subs):
+						splits = []
+						for mem_sym in members.values():
+							mname = str(mem_sym)
+							sig = member_sigs[mem_sym]
+							pq = member_subdiv_mapping[si][mem_sym][qi]
+							splits.append(f'subdiv_{si}_{sig}_{pq}({mname})')
+						for vsym in var_syms.values():
+							vname = str(vsym)
+							splits.append(f'subdiv_{si}_{var_sig}_{qi}({vname})')
+						f.write(f'{name}{{*this, {qi},')
+						f.joint_write(', ', splits)
+						f.write('},')
+					f.write('};')
+				f.write('}')
+
+			# operator<<
+			f.write(f'std::ostream &operator<<(std::ostream &out, const {name} &s) {{')
+			f.write('for (unsigned i=0; i<s.numVertices; ++i) {')
+			f.write(f"out << s.getVertex(i) << ' ';")
+			f.write('}')
+			f.write('return out;')
+			f.write('}')
+
+			f.write('}')
+
+		##########
+		# HEADER #
+		##########
+		with CodeWriter(os.path.join(self.directory, header_name)) as f:
+			f.write('#pragma once')
+			f.write('#include "core/RealVector.hpp"')
+			f.write('#include "core/SubdivHistory.hpp"')
+			f.write()
+			f.write(f'namespace {NAMESPACE} {{')
+			f.write(f'class {name} {{')
+			f.write('public:')
+			f.write(f'static constexpr unsigned dimension = {dim};')
+			f.write(f'static constexpr unsigned numVertices = {num_vertices};')
+			f.write(f'static constexpr unsigned numConstraints = {num_constraints};')
+			f.write(f'static constexpr bool hasObjective = {"true" if has_objective else "false"};')
+			f.write(f'unsigned scheme = 0;')
+			f.write(f'unsigned depth = 0;')
+			f.write(f'std::shared_ptr<const SubdivHistory> history;')
+			f.write()
+
+			# Main constructor declaration
+			if args_decl:
+				f.write(f'{name}(')
+				f.joint_write(',', args_decl)
+				f.write(');')
+				f.write()
+				f.write(f'{name}() = default;')
+			else:
+				f.write(f'{name}();')
+			f.write()
+
+			# schemeSize()
+			f.write('unsigned schemeSize() const {')
+			f.write('auto s = (scheme < schemes.size()) ? scheme : 0;')
+			f.write('return schemes.at(s);')
+			f.write('}')
+			f.write()
+
+			# width()
+			widthlist = [f'{v}.inclusion().width()' for v in var_member_names]
+			f.write('const Real width() const {')
+			f.write('return std::max({')
+			f.joint_write(',', widthlist)
+			f.write('});')
+			f.write('}')
+			f.write()
+
+			# getVertex()
+			getvertlist = [f'{v}[i]' for v in var_member_names]
+			f.write('RealVector<dimension> getVertex(unsigned i) const {')
+			f.write('return {')
+			f.joint_write(',', getvertlist)
+			f.write('};')
+			f.write('}')
+			f.write()
+
+			# schemes array (public, needed as template argument)
+			scheme_sizes = ', '.join(str(len(s)) for s in all_subdivisions)
+			f.write(f'static constexpr std::array<unsigned, {len(all_subdivisions)}> schemes = {{{scheme_sizes}}};')
+			f.write()
+
+			# Method declarations
+			f.write('RealInterval inclusion(unsigned i) const;')
+			f.write(f'RealVector<numVertices> sample(unsigned i) const;')
+			f.write(f'template<unsigned SI=0> std::array<{name}, schemes[SI]> split() const;')
+			f.write(f'void inherit(const {name} &parent, unsigned q);')
+			f.write(f'friend std::ostream &operator<<(std::ostream &out, const {name} &s);')
+			f.write()
+
+			# Private
+			f.write('private:')
+			f.write()
+			for gname, gsyms in raw_arg_groups:
+				if '[' in gsyms[0].name:
+					f.write(f'RealVector<{len(gsyms)}> {gname};')
+				else:
+					f.write(f'Real {gname};')
+			for ms in members.values():
+				f.write(f'RealVector<{poly_sizes[ms]}> {str(ms)};')
+			for vsym in var_syms.values():
+				f.write(f'RealVector<{num_vertices}> {str(vsym)};')
+			f.write()
+
+			# Private subdivision constructor
+			f.write(f'{name}(const {name} &parent, unsigned q,')
+			f.joint_write(',', member_decl)
+			f.write(');')
+			f.write()
+
+			# Static function declarations
+			for sig in self.added_sig:
+				f.write(sig)
+
+			f.write('};')
+			f.write()
+			for si in range(len(all_subdivisions)):
+				f.write(f'template<> std::array<{name}, {name}::schemes[{si}]> {name}::split<{si}>() const;')
+			f.write('}')
+
+	def write_cmakelists(self):
+		''' Write CMakeLists.txt '''
+		self.log.info('Writing CMakeLists.txt')
+		with CodeWriter(os.path.join(self.directory, 'CMakeLists.txt')) as f:
+			f.write('set(SOURCES')
+			for s in self.added_cpp:
+				f.write(s)
+			f.write(')')
+			f.write()
+			f.write(f'target_sources({TARGET_NAME} PRIVATE ${{SOURCES}})')