From 1a8fdc32d3937b10ae005fc19f3d5afb547a35ef Mon Sep 17 00:00:00 2001 From: Aik-Siong Koh Date: Thu, 7 Aug 2025 20:37:33 -0600 Subject: [PATCH] Implement Power function --- OndselSolver/ASMTTime.cpp | 9 ++++ OndselSolver/ASMTTime.h | 3 ++ OndselSolver/Array.h | 18 ++++---- OndselSolver/DifferentiatedGeneralSpline.cpp | 7 ++++ OndselSolver/DifferentiatedGeneralSpline.h | 1 + OndselSolver/ExpressionX.cpp | 4 ++ OndselSolver/ExpressionX.h | 2 + OndselSolver/FunctionX.cpp | 10 ++++- OndselSolver/FunctionX.h | 3 +- OndselSolver/FunctionXY.cpp | 43 ++++++++++++++++++++ OndselSolver/FunctionXY.h | 5 +++ OndselSolver/GeneralSpline.cpp | 7 ++++ OndselSolver/GeneralSpline.h | 1 + OndselSolver/Integral.cpp | 9 ++++ OndselSolver/Integral.h | 2 + OndselSolver/Item.h | 2 +- OndselSolver/PiecewiseFunction.cpp | 8 +++- OndselSolver/PiecewiseFunction.h | 42 ++++++++++--------- OndselSolver/Polynomial.cpp | 11 +++++ OndselSolver/Polynomial.h | 3 ++ OndselSolver/Power.cpp | 31 ++++++++++++-- OndselSolver/Power.h | 5 ++- OndselSolver/Product.cpp | 21 ++++++++-- OndselSolver/RampStepFunction.cpp | 10 ++++- OndselSolver/RampStepFunction.h | 2 + OndselSolver/Sum.cpp | 1 + OndselSolverMain/OndselSolver.cpp | 4 +- 27 files changed, 220 insertions(+), 44 deletions(-) diff --git a/OndselSolver/ASMTTime.cpp b/OndselSolver/ASMTTime.cpp index ec01ebf..13e37e8 100644 --- a/OndselSolver/ASMTTime.cpp +++ b/OndselSolver/ASMTTime.cpp @@ -22,6 +22,10 @@ std::shared_ptr MbD::ASMTTime::With() return asmt; } +MbD::ASMTTime::ASMTTime(Symsptr arg) : ExpressionX(arg) +{ +} + void MbD::ASMTTime::deleteMbD() { xx = nullptr; @@ -56,3 +60,8 @@ void MbD::ASMTTime::setValue(double val) { xx->setValue(val); } + +Symsptr MbD::ASMTTime::copyWith(Symsptr arg) +{ + return std::make_shared(arg); +} diff --git a/OndselSolver/ASMTTime.h b/OndselSolver/ASMTTime.h index c64cb7c..bdacd5f 100644 --- a/OndselSolver/ASMTTime.h +++ b/OndselSolver/ASMTTime.h @@ -18,10 +18,13 @@ namespace MbD { // public: static std::shared_ptr With(); + ASMTTime() = default; + ASMTTime(Symsptr arg); void deleteMbD(); void createMbD(std::shared_ptr mbdSys, std::shared_ptr mbdUnits) override; Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; + Symsptr copyWith(Symsptr arg) override; bool isVariable() override; void setValue(double val) override; diff --git a/OndselSolver/Array.h b/OndselSolver/Array.h index 636e9a5..7851817 100644 --- a/OndselSolver/Array.h +++ b/OndselSolver/Array.h @@ -78,13 +78,17 @@ namespace MbD { this->at(i) = x->at(i); } } - template - inline void Array::zeroSelf() - { - for (size_t i = 0; i < this->size(); i++) { - this->at(i) = (T)0; - } - } + template + inline void Array::zeroSelf() + { + for (size_t i = 0; i < this->size(); i++) { + if constexpr (std::is_pointer::value) { + this->at(i) = nullptr; // Assign nullptr for pointer types + } else { + this->at(i) = T(); // Use default constructor for non-pointer types + } + } + } template inline double Array::rootMeanSquare() { diff --git a/OndselSolver/DifferentiatedGeneralSpline.cpp b/OndselSolver/DifferentiatedGeneralSpline.cpp index 6138b30..dfd302b 100644 --- a/OndselSolver/DifferentiatedGeneralSpline.cpp +++ b/OndselSolver/DifferentiatedGeneralSpline.cpp @@ -37,3 +37,10 @@ std::ostream& MbD::DifferentiatedGeneralSpline::printOn(std::ostream& s) const s << "deriv(" << *generalSpline << ", " << derivativeOrder << ")"; return s; } + +Symsptr MbD::DifferentiatedGeneralSpline::copyWith(Symsptr arg) +{ + auto clone = clonesptr(); + std::static_pointer_cast(clone)->setX(arg); + return clone; +} diff --git a/OndselSolver/DifferentiatedGeneralSpline.h b/OndselSolver/DifferentiatedGeneralSpline.h index bcaace8..1a03d5a 100644 --- a/OndselSolver/DifferentiatedGeneralSpline.h +++ b/OndselSolver/DifferentiatedGeneralSpline.h @@ -20,6 +20,7 @@ namespace MbD { double getValue() override; Symsptr differentiateWRTx() override; Symsptr clonesptr() override; + Symsptr copyWith(Symsptr arg) override; std::ostream& printOn(std::ostream& s) const override; diff --git a/OndselSolver/ExpressionX.cpp b/OndselSolver/ExpressionX.cpp index 2efabb7..604acd3 100644 --- a/OndselSolver/ExpressionX.cpp +++ b/OndselSolver/ExpressionX.cpp @@ -11,6 +11,10 @@ using namespace MbD; +MbD::ExpressionX::ExpressionX(Symsptr arg) : FunctionX(arg) +{ +} + void MbD::ExpressionX::xexpression(Symsptr arg, Symsptr func) { //" diff --git a/OndselSolver/ExpressionX.h b/OndselSolver/ExpressionX.h index cd8beb5..5762d5d 100644 --- a/OndselSolver/ExpressionX.h +++ b/OndselSolver/ExpressionX.h @@ -16,6 +16,8 @@ namespace MbD { // public: + ExpressionX() = default; + ExpressionX(Symsptr arg); void xexpression(Symsptr arg, Symsptr func); Symsptr differentiateWRTx() override; Symsptr differentiateWRT(Symsptr var) override; diff --git a/OndselSolver/FunctionX.cpp b/OndselSolver/FunctionX.cpp index 8126c69..289ea46 100644 --- a/OndselSolver/FunctionX.cpp +++ b/OndselSolver/FunctionX.cpp @@ -19,6 +19,11 @@ MbD::FunctionX::FunctionX(Symsptr arg) : xx(arg) { } +void MbD::FunctionX::setX(Symsptr arg) +{ + xx = arg; +} + void MbD::FunctionX::arguments(Symsptr args) { auto arguments = std::static_pointer_cast(args); @@ -26,9 +31,10 @@ void MbD::FunctionX::arguments(Symsptr args) xx = arguments->terms->front(); } -Symsptr MbD::FunctionX::copyWith(Symsptr self) +Symsptr MbD::FunctionX::copyWith(Symsptr arg) { - return self; + assert(false); + return Symsptr(); } Symsptr MbD::FunctionX::expandUntil(Symsptr sptr, std::shared_ptr> set) diff --git a/OndselSolver/FunctionX.h b/OndselSolver/FunctionX.h index 2aa5505..2621a22 100644 --- a/OndselSolver/FunctionX.h +++ b/OndselSolver/FunctionX.h @@ -20,8 +20,9 @@ namespace MbD { public: FunctionX() = default; FunctionX(Symsptr arg); + void setX(Symsptr arg); void arguments(Symsptr args) override; - virtual Symsptr copyWith(Symsptr arg); + virtual Symsptr copyWith(Symsptr arg) = 0; Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr differentiateWRT(Symsptr var) override; diff --git a/OndselSolver/FunctionXY.cpp b/OndselSolver/FunctionXY.cpp index 8ca66f9..c001aaf 100644 --- a/OndselSolver/FunctionXY.cpp +++ b/OndselSolver/FunctionXY.cpp @@ -8,6 +8,7 @@ #include "FunctionXY.h" #include "Sum.h" +#include "Constant.h" using namespace MbD; @@ -19,6 +20,11 @@ MbD::FunctionXY::FunctionXY(Symsptr base, Symsptr exp) : x(base), y(exp) { } +Symsptr MbD::FunctionXY::copyWith(Symsptr argx, Symsptr argy) +{ + return Symsptr(); +} + void MbD::FunctionXY::arguments(Symsptr args) { //args is a Sum with "terms" containing the actual arguments @@ -28,7 +34,44 @@ void MbD::FunctionXY::arguments(Symsptr args) y = sum->terms->at(1); } +Symsptr MbD::FunctionXY::expandUntil(Symsptr sptr, std::shared_ptr> set) +{ + auto itr = std::find_if(set->begin(), set->end(), [sptr](Symsptr sym) {return sptr.get() == sym.get(); }); + if (itr != set->end()) return sptr; + auto newx = x->expandUntil(x, set); + auto newy = y->expandUntil(y, set); + auto copy = copyWith(newx, newy); + return copy; +} + +Symsptr MbD::FunctionXY::simplifyUntil(Symsptr sptr, std::shared_ptr> set) +{ + auto itr = std::find_if(set->begin(), set->end(), [sptr](Symsptr sym) {return sptr.get() == sym.get(); }); + if (itr != set->end()) return sptr; + auto newx = x->simplifyUntil(x, set); + auto newy = y->simplifyUntil(y, set); + auto copy = copyWith(newx, newy); + return copy; +} + +void MbD::FunctionXY::createMbD(std::shared_ptr mbdSys, std::shared_ptr mbdUnits) +{ + x->createMbD(mbdSys, mbdUnits); + y->createMbD(mbdSys, mbdUnits); +} + bool MbD::FunctionXY::isConstant() { return x->isConstant() && y->isConstant(); } + +Symsptr MbD::FunctionXY::differentiateWRT(Symsptr var) +{ + if (this == var.get()) return sptrConstant(1.0); + auto dfdx = differentiateWRTx(); + auto dfdy = differentiateWRTy(); + auto dxdvar = x->differentiateWRT(var); + auto dydvar = y->differentiateWRT(var); + return Symbolic::sum(Symbolic::times(dfdx, dxdvar), Symbolic::times(dfdy, dydvar)); +} + diff --git a/OndselSolver/FunctionXY.h b/OndselSolver/FunctionXY.h index 2bc59f9..3a97bde 100644 --- a/OndselSolver/FunctionXY.h +++ b/OndselSolver/FunctionXY.h @@ -20,7 +20,12 @@ namespace MbD { public: FunctionXY(); FunctionXY(Symsptr base, Symsptr exp); + virtual Symsptr copyWith(Symsptr argx, Symsptr argy) = 0; + Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; + Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; void arguments(Symsptr args) override; + void createMbD(std::shared_ptr mbdSys, std::shared_ptr mbdUnits) override; + Symsptr differentiateWRT(Symsptr var) override; virtual Symsptr differentiateWRTx() = 0; virtual Symsptr differentiateWRTy() = 0; bool isConstant() override; diff --git a/OndselSolver/GeneralSpline.cpp b/OndselSolver/GeneralSpline.cpp index 6fb27de..8da9dbf 100644 --- a/OndselSolver/GeneralSpline.cpp +++ b/OndselSolver/GeneralSpline.cpp @@ -259,3 +259,10 @@ std::ostream& MbD::GeneralSpline::printOn(std::ostream& s) const s << "})" << std::endl; return s; } + +Symsptr MbD::GeneralSpline::copyWith(Symsptr arg) +{ + auto clone = clonesptr(); + std::static_pointer_cast(clone)->setX(arg); + return clone; +} diff --git a/OndselSolver/GeneralSpline.h b/OndselSolver/GeneralSpline.h index 2fcce7c..55efc66 100644 --- a/OndselSolver/GeneralSpline.h +++ b/OndselSolver/GeneralSpline.h @@ -32,6 +32,7 @@ namespace MbD { void calcIndexAndDelta(); void searchIndexFromto(size_t start, size_t end); Symsptr clonesptr() override; + Symsptr copyWith(Symsptr arg) override; double y(double xxx); std::ostream& printOn(std::ostream& s) const override; diff --git a/OndselSolver/Integral.cpp b/OndselSolver/Integral.cpp index 48c4e27..51b70df 100644 --- a/OndselSolver/Integral.cpp +++ b/OndselSolver/Integral.cpp @@ -2,6 +2,10 @@ using namespace MbD; +MbD::Integral::Integral(Symsptr arg) : ExpressionX(arg) +{ +} + MbD::Integral::Integral(Symsptr, Symsptr) { assert(false); @@ -48,3 +52,8 @@ std::ostream& MbD::Integral::printOn(std::ostream& s) const s << *integrationConstant; return s; } + +Symsptr MbD::Integral::copyWith(Symsptr arg) +{ + return std::make_shared(arg); +} diff --git a/OndselSolver/Integral.h b/OndselSolver/Integral.h index 74650dc..8914519 100644 --- a/OndselSolver/Integral.h +++ b/OndselSolver/Integral.h @@ -16,10 +16,12 @@ namespace MbD { { public: Integral() = default; + Integral(Symsptr arg); Integral(Symsptr var, Symsptr integrand); void arguments(Symsptr args) override; Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; + Symsptr copyWith(Symsptr arg) override; void setIntegrationConstant(double integConstant) override; std::ostream& printOn(std::ostream& s) const override; diff --git a/OndselSolver/Item.h b/OndselSolver/Item.h index ff6e50e..2ebcf4a 100644 --- a/OndselSolver/Item.h +++ b/OndselSolver/Item.h @@ -22,7 +22,7 @@ namespace MbD { class Constraint; class StateData; - class Item + class Item : public std::enable_shared_from_this { //name public: diff --git a/OndselSolver/PiecewiseFunction.cpp b/OndselSolver/PiecewiseFunction.cpp index 81b691b..880d322 100644 --- a/OndselSolver/PiecewiseFunction.cpp +++ b/OndselSolver/PiecewiseFunction.cpp @@ -12,9 +12,8 @@ using namespace MbD; -MbD::PiecewiseFunction::PiecewiseFunction() +MbD::PiecewiseFunction::PiecewiseFunction(Symsptr arg) : FunctionXcParameter(arg) { - noop(); } MbD::PiecewiseFunction::PiecewiseFunction(Symsptr var, std::shared_ptr> funcs, std::shared_ptr> trans) @@ -121,3 +120,8 @@ std::ostream& MbD::PiecewiseFunction::printOn(std::ostream& s) const s << "})" << std::endl; return s; } + +Symsptr MbD::PiecewiseFunction::copyWith(Symsptr arg) +{ + return std::make_shared(arg, functions, transitions); +} diff --git a/OndselSolver/PiecewiseFunction.h b/OndselSolver/PiecewiseFunction.h index 1fcac7f..ce7f0e0 100644 --- a/OndselSolver/PiecewiseFunction.h +++ b/OndselSolver/PiecewiseFunction.h @@ -11,27 +11,29 @@ #include "FunctionXcParameter.h" namespace MbD { - class Symbolic; - using Symsptr = std::shared_ptr; - - class PiecewiseFunction : public FunctionXcParameter - { - //functions transitions - //func0 tran0 func1 tran1 func2 - public: - PiecewiseFunction(); - PiecewiseFunction(Symsptr var, std::shared_ptr> funcs, std::shared_ptr> trans); - Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; - Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; - Symsptr differentiateWRTx() override; - Symsptr integrateWRT(Symsptr var) override; - double getValue() override; - void arguments(Symsptr args) override; + class Symbolic; + using Symsptr = std::shared_ptr; - std::ostream& printOn(std::ostream& s) const override; + class PiecewiseFunction : public FunctionXcParameter + { + //functions transitions + //func0 tran0 func1 tran1 func2 + public: + PiecewiseFunction() = default; + PiecewiseFunction(Symsptr arg); + PiecewiseFunction(Symsptr var, std::shared_ptr> funcs, std::shared_ptr> trans); + Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; + Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; + Symsptr differentiateWRTx() override; + Symsptr integrateWRT(Symsptr var) override; + Symsptr copyWith(Symsptr arg) override; + double getValue() override; + void arguments(Symsptr args) override; - std::shared_ptr> functions = std::make_shared>(); - std::shared_ptr> transitions = std::make_shared>(); + std::ostream& printOn(std::ostream& s) const override; - }; + std::shared_ptr> functions = std::make_shared>(); + std::shared_ptr> transitions = std::make_shared>(); + + }; } diff --git a/OndselSolver/Polynomial.cpp b/OndselSolver/Polynomial.cpp index b1c7d87..82d3aa1 100644 --- a/OndselSolver/Polynomial.cpp +++ b/OndselSolver/Polynomial.cpp @@ -14,6 +14,10 @@ using namespace MbD; +MbD::Polynomial::Polynomial(Symsptr arg) : FunctionXcParameter(arg) +{ +} + MbD::Polynomial::Polynomial(Symsptr var, std::shared_ptr> coefficients) { assert(!coefficients->empty()); @@ -120,3 +124,10 @@ std::ostream& MbD::Polynomial::printOn(std::ostream& s) const s << "})"; return s; } + +Symsptr MbD::Polynomial::copyWith(Symsptr arg) +{ + auto clone = clonesptr(); + std::static_pointer_cast(clone)->setX(arg); + return clone; +} diff --git a/OndselSolver/Polynomial.h b/OndselSolver/Polynomial.h index 90bad36..3beab6e 100644 --- a/OndselSolver/Polynomial.h +++ b/OndselSolver/Polynomial.h @@ -15,12 +15,15 @@ namespace MbD { { //pn = a0*x^0 + a1*x^1 ... an*x^n public: + Polynomial() = default; + Polynomial(Symsptr arg); Polynomial(Symsptr var, std::shared_ptr> coeffs); Polynomial(Symsptr var, std::shared_ptr> coeffs); Symsptr expandUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; Symsptr differentiateWRTx() override; Symsptr integrateWRT(Symsptr var) override; + Symsptr copyWith(Symsptr arg) override; double getValue() override; void setIntegrationConstant(double integConstant) override; diff --git a/OndselSolver/Power.cpp b/OndselSolver/Power.cpp index 489d924..bd1d774 100644 --- a/OndselSolver/Power.cpp +++ b/OndselSolver/Power.cpp @@ -5,7 +5,7 @@ * * * See LICENSE file for details about copyright. * ***************************************************************************/ - + #include "Power.h" #include "Constant.h" #include "Ln.h" @@ -35,13 +35,36 @@ Symsptr MbD::Power::differentiateWRTy() return deriv->simplified(); } -Symsptr MbD::Power::simplifyUntil(Symsptr, std::shared_ptr>) +Symsptr MbD::Power::copyWith(Symsptr argx, Symsptr argy) { - assert(false); - return Symsptr(); + return std::make_shared(argx, argy); } double MbD::Power::getValue() { return std::pow(x->getValue(), y->getValue()); } + +Symsptr MbD::Power::clonesptr() +{ + return std::make_shared(*this); +} + +Symsptr MbD::Power::simplifyUntil(Symsptr sptr, std::shared_ptr> set) +{ + auto itr = std::find_if(set->begin(), set->end(), [sptr](Symsptr sym) {return sptr.get() == sym.get(); }); + if (itr != set->end()) return sptr; + auto newx = x->simplifyUntil(x, set); + auto newy = y->simplifyUntil(y, set); + if (y->isConstant() && y->getValue() == 1) { + return newx; + } + auto copy = copyWith(newx, newy); + return copy; +} + +std::ostream& MbD::Power::printOn(std::ostream& s) const +{ + s << "pow(" << *x << "," << *y << ")"; + return s; +} diff --git a/OndselSolver/Power.h b/OndselSolver/Power.h index de16653..3545c23 100644 --- a/OndselSolver/Power.h +++ b/OndselSolver/Power.h @@ -19,10 +19,13 @@ namespace MbD { Power(Symsptr base, Symsptr exp); Symsptr differentiateWRTx() override; Symsptr differentiateWRTy() override; - + Symsptr copyWith(Symsptr argx, Symsptr argy) override; + Symsptr clonesptr() override; Symsptr simplifyUntil(Symsptr sptr, std::shared_ptr> set) override; double getValue() override; + std::ostream& printOn(std::ostream& s) const override; + }; } diff --git a/OndselSolver/Product.cpp b/OndselSolver/Product.cpp index 0aced6c..3791c49 100644 --- a/OndselSolver/Product.cpp +++ b/OndselSolver/Product.cpp @@ -5,7 +5,7 @@ * * * See LICENSE file for details about copyright. * ***************************************************************************/ - + #include #include @@ -24,7 +24,7 @@ Symsptr MbD::Product::differentiateWRT(Symsptr var) std::transform(terms->begin(), terms->end(), std::back_inserter(*derivatives), - [var](Symsptr term) { + [var](Symsptr term) { return term->differentiateWRT(var); } ); @@ -162,7 +162,22 @@ bool Product::isProduct() double Product::getValue() { double answer = 1.0; - for (size_t i = 0; i < terms->size(); i++) answer *= terms->at(i)->getValue(); + bool hasInfinity = false; + for (size_t i = 0; i < terms->size(); i++) + { + double termValue = terms->at(i)->getValue(); + if (termValue == 0.0) { + return 0.0; // If any term is zero, the product is zero + } + if (std::isfinite(termValue)) { + answer *= termValue; + } + else { + hasInfinity = true; + //Continue to look for a zero term. + } + } + assert(!hasInfinity); return answer; } diff --git a/OndselSolver/RampStepFunction.cpp b/OndselSolver/RampStepFunction.cpp index 2c0bff3..12fac88 100644 --- a/OndselSolver/RampStepFunction.cpp +++ b/OndselSolver/RampStepFunction.cpp @@ -6,9 +6,12 @@ using namespace MbD; +MbD::RampStepFunction::RampStepFunction(Symsptr arg) : PiecewiseFunction(arg) +{ +} + MbD::RampStepFunction::RampStepFunction(Symsptr var, std::shared_ptr> consts, std::shared_ptr> trans) { - double x0 = trans->at(0); double x1 = trans->at(1); double y0 = consts->at(0); @@ -60,3 +63,8 @@ void MbD::RampStepFunction::initFunctionsTransitions(Symsptr var, double x0, dou transitions->push_back(symx0); transitions->push_back(symx1); } + +Symsptr MbD::RampStepFunction::copyWith(Symsptr arg) +{ + return std::make_shared(arg); +} diff --git a/OndselSolver/RampStepFunction.h b/OndselSolver/RampStepFunction.h index cf79b5f..5185a5a 100644 --- a/OndselSolver/RampStepFunction.h +++ b/OndselSolver/RampStepFunction.h @@ -15,10 +15,12 @@ namespace MbD { { public: RampStepFunction() = default; + RampStepFunction(Symsptr arg); RampStepFunction(Symsptr var, std::shared_ptr> consts, std::shared_ptr> trans); void arguments(Symsptr args) override; void initFunctionsTransitions(Symsptr var, double x0, double y0, double x1, double y1); void initFunctionsTransitions(Symsptr var, double x0, double y0, double x1, double y1, Symsptr symx0, Symsptr symy0, Symsptr symx1, Symsptr symy1); + Symsptr copyWith(Symsptr arg) override; }; } diff --git a/OndselSolver/Sum.cpp b/OndselSolver/Sum.cpp index d6b320e..ec5f1c6 100644 --- a/OndselSolver/Sum.cpp +++ b/OndselSolver/Sum.cpp @@ -126,6 +126,7 @@ double Sum::getValue() { double answer = 0.0; for (size_t i = 0; i < terms->size(); i++) answer += terms->at(i)->getValue(); + assert(std::isfinite(answer)); return answer; } diff --git a/OndselSolverMain/OndselSolver.cpp b/OndselSolverMain/OndselSolver.cpp index 97ab5b9..eccb97c 100644 --- a/OndselSolverMain/OndselSolver.cpp +++ b/OndselSolverMain/OndselSolver.cpp @@ -23,8 +23,8 @@ void sharedptrTest(); int main() { - //ASMTAssembly::runFile("C:/Users/askoh/OneDrive/askoh/visualstudio/Ondsel/OndselFreeCAD/build/src/Main/runDragStep.asmt"); - //return 0; + ASMTAssembly::runFile("C:/Users/askoh/Downloads/pistonDebug.asmt"); + return 0; //auto assembly = ASMTAssembly::assemblyFromFile("C:/Users/askoh/OneDrive/askoh/visualstudio/Ondsel/OndselFreeCAD/build/src/Main/runPreDrag.asmt"); //assembly->runDraggingLog("C:/Users/askoh/OneDrive/askoh/visualstudio/Ondsel/OndselFreeCAD/build/src/Main/dragging.log"); //return 0;