void bvisit(const Mul &x) { RCP<const Basic> curr_num = one; RCP<const Basic> curr_den = one; RCP<const Basic> arg_num, arg_den, t; for (const auto &arg : x.get_args()) { as_numer_denom(arg, outArg(arg_num), outArg(arg_den)); // TODO: This is naive and slow. Fix it t = div(curr_num, arg_den); if (neq(*t, x)) { as_numer_denom(t, outArg(curr_num), outArg(arg_den)); } t = div(curr_den, arg_num); if (neq(*t, x)) { as_numer_denom(t, outArg(curr_den), outArg(arg_num)); } curr_num = mul(curr_num, arg_num); curr_den = mul(curr_den, arg_den); } *numer_ = curr_num; *denom_ = curr_den; }
int main() { if (nge(INT_MIN, INT_MAX) != 0) abort(); if (nge(INT_MAX, INT_MIN) != -1) abort(); if (ngt(INT_MIN, INT_MAX) != 0) abort(); if (ngt(INT_MAX, INT_MIN) != -1) abort(); if (nle(INT_MIN, INT_MAX) != -1) abort(); if (nle(INT_MAX, INT_MIN) != 0) abort(); if (nlt(INT_MIN, INT_MAX) != -1) abort(); if (nlt(INT_MAX, INT_MIN) != 0) abort(); if (neq(INT_MIN, INT_MAX) != 0) abort(); if (neq(INT_MAX, INT_MIN) != 0) abort(); if (nne(INT_MIN, INT_MAX) != -1) abort(); if (nne(INT_MAX, INT_MIN) != -1) abort(); if (ngeu(0, ~0U) != 0) abort(); if (ngeu(~0U, 0) != -1) abort(); if (ngtu(0, ~0U) != 0) abort(); if (ngtu(~0U, 0) != -1) abort(); if (nleu(0, ~0U) != -1) abort(); if (nleu(~0U, 0) != 0) abort(); if (nltu(0, ~0U) != -1) abort(); if (nltu(~0U, 0) != 0) abort(); exit(0); }
void ReactorNet::initialize() { size_t n, nv; char buf[100]; m_nv = 0; writelog("Initializing reactor network.\n", m_verbose); if (m_reactors.empty()) throw CanteraError("ReactorNet::initialize", "no reactors in network!"); size_t sensParamNumber = 0; m_start.assign(1, 0); for (n = 0; n < m_reactors.size(); n++) { Reactor& r = *m_reactors[n]; r.initialize(m_time); nv = r.neq(); m_nparams.push_back(r.nSensParams()); std::vector<std::pair<void*, int> > sens_objs = r.getSensitivityOrder(); for (size_t i = 0; i < sens_objs.size(); i++) { std::map<size_t, size_t>& s = m_sensOrder[sens_objs[i]]; for (std::map<size_t, size_t>::iterator iter = s.begin(); iter != s.end(); ++iter) { m_sensIndex.resize(std::max(iter->second + 1, m_sensIndex.size())); m_sensIndex[iter->second] = sensParamNumber++; } } m_nv += nv; m_start.push_back(m_nv); if (m_verbose) { sprintf(buf,"Reactor %s: %s variables.\n", int2str(n).c_str(), int2str(nv).c_str()); writelog(buf); sprintf(buf," %s sensitivity params.\n", int2str(r.nSensParams()).c_str()); writelog(buf); } if (r.type() == FlowReactorType && m_reactors.size() > 1) { throw CanteraError("ReactorNet::initialize", "FlowReactors must be used alone."); } } m_ydot.resize(m_nv,0.0); m_atol.resize(neq()); fill(m_atol.begin(), m_atol.end(), m_atols); m_integ->setTolerances(m_rtol, neq(), DATA_PTR(m_atol)); m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens); m_integ->setMaxStepSize(m_maxstep); m_integ->setMaxErrTestFails(m_maxErrTestFails); if (m_verbose) { sprintf(buf, "Number of equations: %s\n", int2str(neq()).c_str()); writelog(buf); sprintf(buf, "Maximum time step: %14.6g\n", m_maxstep); writelog(buf); } m_integ->initialize(m_time, *this); m_integrator_init = true; m_init = true; }
void testPtrs(void) { #ifndef __SDCC_pic16 #if defined (__SDCC_MODEL_HUGE) char __code * cp2 = (char __code *)0x0002; void (* fp2)(void) = (void (*)(void))0x0002; ASSERT (eq(cp2, fp2)); ASSERT (smaller(fpE, fpF)); #endif ASSERT (xp0 == NULL); ASSERT (ip0 == NULL); ASSERT (pp0 == NULL); ASSERT (cp0 == NULL); ASSERT (fp0 == NULL); ASSERT (gp0 == NULL); ASSERT (xp1 != NULL); ASSERT (ip1 != NULL); ASSERT (pp1 != NULL); ASSERT (cp1 != NULL); ASSERT (fp1 != NULL); ASSERT (gp2 != NULL); ASSERT (eq(xp0, ip0)); ASSERT (eq(xp0, pp0)); ASSERT (eq(xp0, cp0)); ASSERT (eq(xp0, fp0)); ASSERT (eq(xp0, gp0)); #if defined(__SDCC_mcs51) || defined(__SDCC_ds390) ASSERT (neq(xp1, ip1)); ASSERT (neq(xp1, pp1)); ASSERT (neq(xp1, cp1)); ASSERT (neq(xp1, fp1)); ASSERT (neq(xp1, gp2)); ASSERT (smaller(xp1, ip1) || greater(xp1, ip1)); ASSERT (smaller(xp1, pp1) || greater(xp1, pp1)); ASSERT (smaller(xp1, cp1) || greater(xp1, cp1)); ASSERT (smaller(xp1, fp1) || greater(xp1, fp1)); ASSERT (smaller(xp1, gp2) || greater(xp1, gp2)); ASSERT (!smaller(xp0, ip0) && !greater(xp0, ip0)); ASSERT (!smaller(xp0, pp0) && !greater(xp0, pp0)); ASSERT (!smaller(xp0, cp0) && !greater(xp0, cp0)); ASSERT (!smaller(xp0, fp0) && !greater(xp0, fp0)); ASSERT (!smaller(xp0, gp0) && !greater(xp0, gp0)); #endif ASSERT (eq(cp1, fp1)); ASSERT (smaller(pp1, gp2)); #endif }
RCP<const Set> Interval::set_intersection(const RCP<const Set> &o) const { if (is_a<Interval>(*o)) { const Interval &other = static_cast<const Interval &>(*o); RCP<const Number> start, end; bool left_open, right_open; RCP<const Basic> start_end, end_start; start_end = min({this->start_, other.end_}); end_start = min({this->end_, other.start_}); if (eq(*this->start_, *start_end) and eq(*other.start_, *end_start)) { RCP<const Basic> start_start, end_end; start_start = min({this->start_, other.start_}); end_end = min({this->end_, other.end_}); if (neq(*this->start_, *other.start_)) { if (eq(*this->start_, *start_start)) { start = other.start_; left_open = other.left_open_; } else { start = this->start_; left_open = this->left_open_; } } else { start = this->start_; left_open = this->left_open_ or other.left_open_; } if (neq(*this->end_, *other.end_)) { if (eq(*this->end_, *end_end)) { end = this->end_; right_open = this->right_open_; } else { end = other.end_; right_open = other.right_open_; } } else { end = this->end_; right_open = this->right_open_ or other.right_open_; } return interval(start, end, left_open, right_open); } else { return emptyset(); } } if (is_a<UniversalSet>(*o) or is_a<EmptySet>(*o) or is_a<FiniteSet>(*o) or is_a<Union>(*o)) { return (*o).set_intersection(rcp_from_this_cast<const Set>()); } throw std::runtime_error("Not implemented"); }
std::string Mul::__str__() const { std::ostringstream o; if (eq(coef_, minus_one)) { o << "-"; } else if (is_a<Rational>(*coef_) && !(rcp_static_cast<const Rational>(coef_)->is_int())) { o << "(" << *coef_ <<")"; } else if (is_a<Complex>(*coef_)) { if (!(rcp_static_cast<const Complex>(coef_)->is_reim_zero())) { o << "(" << *coef_ <<")"; } else { o << *coef_; } } else if (neq(coef_, one)) { o << *coef_; } auto p = dict_.begin(); if (neq(coef_, minus_one) && neq(coef_, one)) o << "*"; for (; p != dict_.end(); p++) { if (is_a<Add>(*(p->first))) { o << "(" << *(p->first) << ")"; } else if (is_a<Rational>(*(p->first)) && !(rcp_static_cast<const Rational>((p->first))->is_int())) { o << "(" << *(p->first) <<")"; } else if (is_a<Complex>(*(p->first))) { if (!(rcp_static_cast<const Complex>((p->first))->is_reim_zero())) { o << "(" << *(p->first) <<")"; } else { o << *(p->first); } } else { o << *(p->first); } if (neq(p->second, one)) { o << "^"; if (!is_a<Integer>(*(p->second)) && !is_a<Symbol>(*(p->second))) o << "("; o << *(p->second); if (!is_a<Integer>(*(p->second)) && !is_a<Symbol>(*(p->second))) o << ")"; } o << "*"; } std::string s = o.str(); return s.substr(0, s.size()-1); }
void UmlExtraClassMember::add_init(UmlClass * cl, WrapperStr def, bool roundtrip, QList<UmlItem *> & expected_order) { if (roundtrip) { const QVector<UmlItem*> & ch = cl->children(); UmlItem *const* v = ch.data(); UmlItem *const* vsup = v + ch.size(); UmlItem * x; for (; v != vsup; v += 1) { if (((x = *v)->kind() == anExtraClassMember) && ((UmlExtraClassMember *) x)->is_useless() && (x->name() == "initialization")) { expected_order.append(x); if (neq(((UmlExtraClassMember *) x)->javaDecl(), def)) { ((UmlExtraClassMember *) x)->set_JavaDecl(def); cl->get_class()->set_updated(); } ((UmlExtraClassMember *) x)->set_usefull(); return; } } } UmlExtraClassMember * x = UmlExtraClassMember::create(cl, "initialization"); x->set_JavaDecl(def); expected_order.append(x); }
void StrPrinter::bvisit(const Add &x) { std::ostringstream o; bool first = true; std::map<RCP<const Basic>, RCP<const Number>, RCPBasicKeyLessCmp> dict(x.dict_.begin(), x.dict_.end()); if (neq(*(x.coef_), *zero)) { o << this->apply(x.coef_); first = false; } for (auto &p: dict) { std::string t; if (eq(*(p.second), *one)) { t = this->apply(p.first); } else if(eq(*(p.second), *minus_one)) { t = "-" + parenthesizeLT(p.first, PrecedenceEnum::Mul); } else { t = parenthesizeLT(p.second, PrecedenceEnum::Mul) + "*" + parenthesizeLT(p.first, PrecedenceEnum::Mul); } if (!first) { if (t[0] == '-') { o << " - " << t.substr(1); } else { o << " + " << t; } } else { o << t; first = false; } } str_ = o.str(); }
bool CSRMatrix::eq(const MatrixBase &other) const { unsigned row = this->nrows(); if (row != other.nrows() or this->ncols() != other.ncols()) return false; if (is_a<CSRMatrix>(other)) { const CSRMatrix &o = down_cast<const CSRMatrix &>(other); if (this->p_[row] != o.p_[row]) return false; for (unsigned i = 0; i <= row; i++) if (this->p_[i] != o.p_[i]) return false; for (unsigned i = 0; i < this->p_[row]; i++) if ((this->j_[i] != o.j_[i]) or neq(*this->x_[i], *(o.x_[i]))) return false; return true; } else { return this->MatrixBase::eq(other); } }
void StrPrinter::bvisit(const Mul &x) { std::ostringstream o, o2; bool num = false; unsigned den = 0; std::map<RCP<const Basic>, RCP<const Basic>, RCPBasicKeyLessCmp> dict(x.dict_.begin(), x.dict_.end()); if (eq(*(x.coef_), *minus_one)) { o << "-"; } else if (neq(*(x.coef_), *one)) { o << parenthesizeLT(x.coef_, PrecedenceEnum::Mul) << "*"; num = true; } for (auto &p: dict) { if ((is_a<Integer>(*p.second) && rcp_static_cast<const Integer>(p.second)->is_negative()) || (is_a<Rational>(*p.second) && rcp_static_cast<const Rational>(p.second)->is_negative())) { if(eq(*(p.second), *minus_one)) { o2 << parenthesizeLT(p.first, PrecedenceEnum::Mul); } else { o2 << parenthesizeLE(p.first, PrecedenceEnum::Pow); o2 << "**"; o2 << parenthesizeLE(neg(p.second), PrecedenceEnum::Pow); } o2 << "*"; den++; } else { if(eq(*(p.second), *one)) { o << parenthesizeLT(p.first, PrecedenceEnum::Mul); } else { o << parenthesizeLE(p.first, PrecedenceEnum::Pow); o << "**"; o << parenthesizeLE(p.second, PrecedenceEnum::Pow); } o << "*"; num = true; } } if (!num) { o << "1*"; } std::string s = o.str(); s = s.substr(0, s.size() - 1); if (den != 0) { std::string s2 = o2.str(); s2 = s2.substr(0, s2.size() - 1); if (den > 1) { str_ = s + "/(" + s2 + ")"; } else { str_ = s + "/" + s2; } } else { str_ = s; } }
unsigned pivot(DenseMatrix &B, unsigned r, unsigned c) { unsigned k = r; if (eq(*(B.m_[r * B.col_ + c]), *zero)) for (k = r; k < B.row_; k++) if (neq(*(B.m_[k * B.col_ + c]), *zero)) break; return k; }
bool vec_basic_eq(const vec_basic &a, const vec_basic &b) { // Can't be equal if # of entries differ: if (a.size() != b.size()) return false; // Loop over elements in "a" and "b": for (size_t i = 0; i < a.size(); i++) { if (neq(*a[i], *b[i])) return false; // values not equal } return true; }
int check(int size, float *dataOut, float *expectedOut) { int status = 0; for (int i = 0; i < size ; i++) { if (neq(dataOut[i],expectedOut[i])) { //fprintf(stderr, "Error in output data at location %d, expected %g, received %g\n",i, expectedOut[i], dataOut[i]); status = 1; } } return status; }
std::string Add::__str__() const { std::ostringstream o; if (neq(coef_, zero)) o << *coef_ << " + "; int counter = 0; for (auto &p: dict_) { if (eq(p.second, one)) o << *(p.first); else { // TODO: extend this for Rationals as well: if (is_a<Integer>(*p.second) && rcp_static_cast<const Integer>(p.second)->is_negative() && o.tellp() >= 3) o.seekp(-3, std::ios_base::cur); if (eq(p.second, minus_one)) { if (counter >= 1) o << " - "; else o << "-"; } else { // TODO: extend this for Rationals as well: if (is_a<Integer>(*p.second) && rcp_static_cast<const Integer>(p.second)->is_negative()) { if (counter >= 1) { o << " - "; } else { o << "-"; } o << -(rcp_static_cast<const Integer>(p.second))->i; } else if (is_a<Complex>(*p.second)) { if (!(rcp_static_cast<const Complex>(p.second)->is_reim_zero())) { o << "(" << *(p.second) <<")"; } else { o << *(p.second); } } else { o << *(p.second); } } if (!eq(p.second, minus_one)) o << "*"; if (is_a<Add>(*p.first) || is_a<Rational>(*p.first) || is_a<Complex>(*p.first)) { o << "("; } o << *(p.first); if (is_a<Add>(*p.first) || is_a<Rational>(*p.first) || is_a<Complex>(*p.first)) o << ")"; } o << " + "; counter++; } o.seekp(-3, std::ios_base::cur); std::string s = o.str(); return s.substr(0, o.tellp()); }
void ReactorNet::initialize() { m_nv = 0; debuglog("Initializing reactor network.\n", m_verbose); if (m_reactors.empty()) { throw CanteraError("ReactorNet::initialize", "no reactors in network!"); } m_start.assign(1, 0); for (size_t n = 0; n < m_reactors.size(); n++) { Reactor& r = *m_reactors[n]; r.initialize(m_time); size_t nv = r.neq(); m_nv += nv; m_start.push_back(m_nv); if (m_verbose) { writelog("Reactor {:d}: {:d} variables.\n", n, nv); writelog(" {:d} sensitivity params.\n", r.nSensParams()); } if (r.type() == FlowReactorType && m_reactors.size() > 1) { throw CanteraError("ReactorNet::initialize", "FlowReactors must be used alone."); } } m_ydot.resize(m_nv,0.0); m_atol.resize(neq()); fill(m_atol.begin(), m_atol.end(), m_atols); m_integ->setTolerances(m_rtol, neq(), m_atol.data()); m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens); m_integ->setMaxStepSize(m_maxstep); m_integ->setMaxErrTestFails(m_maxErrTestFails); if (m_verbose) { writelog("Number of equations: {:d}\n", neq()); writelog("Maximum time step: {:14.6g}\n", m_maxstep); } m_integ->initialize(m_time, *this); m_integrator_init = true; m_init = true; }
bool set_eq(const T &A, const T &B) { // Can't be equal if # of entries differ: if (A.size() != B.size()) return false; // Loop over elements in "a" and "b": auto a = A.begin(); auto b = B.begin(); for (; a != A.end(); ++a, ++b) { if (neq(**a, **b)) return false; // values not equal } return true; }
bool MatrixBase::eq(const MatrixBase &other) const { if (this->nrows() != other.nrows() || this->ncols() != other.ncols()) return false; for (unsigned i = 0; i < this->nrows(); i++) for (unsigned j = 0; j < this->ncols(); j++) if(neq(this->get(i, j), other.get(i, j))) return false; return true; }
// Pass 2 computes CSR entries for matrix C = A*B using the // row pointer Cp[] computed in Pass 1. void csr_matmat_pass2(const CSRMatrix &A, const CSRMatrix &B, CSRMatrix &C) { std::vector<int> next(A.col_, -1); vec_basic sums(A.col_, zero); unsigned nnz = 0; C.p_[0] = 0; for (unsigned i = 0; i < A.row_; i++) { int head = -2; unsigned length = 0; unsigned jj_start = A.p_[i]; unsigned jj_end = A.p_[i + 1]; for (unsigned jj = jj_start; jj < jj_end; jj++) { unsigned j = A.j_[jj]; RCP<const Basic> v = A.x_[jj]; unsigned kk_start = B.p_[j]; unsigned kk_end = B.p_[j + 1]; for (unsigned kk = kk_start; kk < kk_end; kk++) { unsigned k = B.j_[kk]; sums[k] = add(sums[k], mul(v, B.x_[kk])); if (next[k] == -1) { next[k] = head; head = k; length++; } } } for (unsigned jj = 0; jj < length; jj++) { if (neq(*sums[head], *zero)) { C.j_[nnz] = head; C.x_[nnz] = sums[head]; nnz++; } unsigned temp = head; head = next[head]; next[temp] = -1; // clear arrays sums[temp] = zero; } C.p_[i + 1] = nnz; } }
// ----------------------------- Determinant ---------------------------------// RCP<const Basic> det_bareis(const DenseMatrix &A) { SYMENGINE_ASSERT(A.row_ == A.col_); unsigned n = A.row_; if (n == 1) { return A.m_[0]; } else if (n == 2) { // If A = [[a, b], [c, d]] then det(A) = ad - bc return sub(mul(A.m_[0], A.m_[3]), mul(A.m_[1], A.m_[2])); } else if (n == 3) { // if A = [[a, b, c], [d, e, f], [g, h, i]] then // det(A) = (aei + bfg + cdh) - (ceg + bdi + afh) return sub(add(add(mul(mul(A.m_[0], A.m_[4]), A.m_[8]), mul(mul(A.m_[1], A.m_[5]), A.m_[6])), mul(mul(A.m_[2], A.m_[3]), A.m_[7])), add(add(mul(mul(A.m_[2], A.m_[4]), A.m_[6]), mul(mul(A.m_[1], A.m_[3]), A.m_[8])), mul(mul(A.m_[0], A.m_[5]), A.m_[7]))); } else { DenseMatrix B = DenseMatrix(n, n, A.m_); unsigned i, sign = 1; RCP<const Basic> d; for (unsigned k = 0; k < n - 1; k++) { if (eq(*(B.m_[k * n + k]), *zero)) { for (i = k + 1; i < n; i++) if (neq(*(B.m_[i * n + k]), *zero)) { row_exchange_dense(B, i, k); sign *= -1; break; } if (i == n) return zero; } for (i = k + 1; i < n; i++) { for (unsigned j = k + 1; j < n; j++) { d = sub(mul(B.m_[k * n + k], B.m_[i * n + j]), mul(B.m_[i * n + k], B.m_[k * n + j])); if (k > 0) d = div(d, B.m_[(k - 1) * n + k - 1]); B.m_[i * n + j] = d; } } } return (sign == 1) ? B.m_[n * n - 1] : mul(minus_one, B.m_[n * n - 1]); } }
RCP<const Set> Interval::set_union(const RCP<const Set> &o) const { if (is_a<Interval>(*o)) { const Interval &other = static_cast<const Interval &>(*o); RCP<const Basic> start_start, end_end, m; RCP<const Number> start, end; bool left_open, right_open; start_start = max({this->start_, other.start_}); end_end = min({this->end_, other.end_}); m = min({start_start, end_end}); if ((eq(*end_end, *start_start) and eq(*end_end, *m) and ((eq(*end_end, *this->end_) and this->right_open_) or (eq(*end_end, *other.end_) and other.right_open_))) or (eq(*end_end, *m) and not eq(*end_end, *start_start))) { return SymEngine::set_union({rcp_from_this_cast<const Set>(), o}, false); } else { if (eq(*min({this->start_, other.start_}), *this->start_)) start = this->start_; else start = other.start_; if (eq(*max({this->end_, other.end_}), *this->end_)) end = this->end_; else end = other.end_; left_open = ((neq(*this->start_, *start) or this->left_open_) and (neq(*other.start_, *start) or other.left_open_)); right_open = ((neq(*this->end_, *end) or this->right_open_) and (neq(*other.end_, *end) or other.right_open_)); return interval(start, end, left_open, right_open); } } if (is_a<UniversalSet>(*o) or is_a<EmptySet>(*o) or is_a<FiniteSet>(*o) or is_a<Union>(*o)) { return (*o).set_union(rcp_from_this_cast<const Set>()); } return SymEngine::set_union({rcp_from_this_cast<const Set>(), o}, false); }
static RCP<const Basic> diff(const FunctionSymbol &self, const RCP<const Symbol> &x) { RCP<const Basic> diff = zero, t; RCP<const Basic> self_ = self.rcp_from_this(); RCP<const Symbol> s; std::string name; unsigned count = 0; bool found_x = false; for (const auto &a : self.get_args()) { if (eq(*a, *x)) { found_x = true; count++; } else if (count < 2 and neq(*a->diff(x), *zero)) { count++; } } if (count == 1 and found_x) { return Derivative::create(self_, {x}); } for (unsigned i = 0; i < self.get_args().size(); i++) { t = self.get_args()[i]->diff(x); if (neq(*t, *zero)) { name = "x"; do { name = "_" + name; s = symbol(name); } while (has_symbol(*self_, s)); vec_basic v = self.get_args(); v[i] = s; map_basic_basic m; insert(m, v[i], self.get_args()[i]); diff = add(diff, mul(t, make_rcp<const Subs>(Derivative::create(self.create(v), {v[i]}), m))); } } return diff; }
void CSRMatrix::set(unsigned i, unsigned j, const RCP<const Basic> &e) { SYMENGINE_ASSERT(i < row_ and j < col_); unsigned k = p_[i]; unsigned row_end = p_[i + 1]; unsigned end = p_[i + 1]; unsigned mid; while (k < end) { mid = (k + end) / 2; if (mid == k) { if (j_[k] < j) { k++; } break; } else if (j_[mid] >= j and j_[mid - 1] < j) { k = mid; break; } else if (j_[mid - 1] >= j) { end = mid - 1; } else { k = mid + 1; } } if (neq(*e, *zero)) { if (k < row_end and j_[k] == j) { x_[k] = e; } else { // j_[k] > j or k is the last non-zero element x_.insert(x_.begin() + k, e); j_.insert(j_.begin() + k, j); for (unsigned l = i + 1; l <= row_; l++) p_[l]++; } } else { // e is zero if (k < row_end and j_[k] == j) { // remove existing non-zero element x_.erase(x_.begin() + k); j_.erase(j_.begin() + k); for (unsigned l = i + 1; l <= row_; l++) p_[l]--; } } }
void Add::as_coef_term(const RCP<const Basic> &self, const Ptr<RCP<const Number>> &coef, const Ptr<RCP<const Basic>> &term) { if (is_a<Mul>(*self)) { if (neq(*(rcp_static_cast<const Mul>(self)->coef_), *one)) { *coef = (rcp_static_cast<const Mul>(self))->coef_; // We need to copy our 'dict_' here, as 'term' has to have its own. map_basic_basic d2 = (rcp_static_cast<const Mul>(self))->dict_; *term = Mul::from_dict(one, std::move(d2)); } else { *coef = one; *term = self; } } else if (is_a_Number(*self)) { *coef = rcp_static_cast<const Number>(self); *term = one; } else { SYMENGINE_ASSERT(not is_a<Add>(*self)); *coef = one; *term = self; } }
// SymPy LUDecomposition_Simple algorithm, in // sympy.matrices.matrices.Matrix.LUdecomposition_Simple with pivoting. // P must be an initialized matrix and will be permuted. void pivoted_LU(const DenseMatrix &A, DenseMatrix &LU, permutelist &pl) { SYMENGINE_ASSERT(A.row_ == A.col_ and LU.row_ == LU.col_); SYMENGINE_ASSERT(A.row_ == LU.row_); unsigned n = A.row_; unsigned i, j, k; RCP<const Basic> scale; int pivot; LU.m_ = A.m_; for (j = 0; j < n; j++) { for (i = 0; i < j; i++) for (k = 0; k < i; k++) LU.m_[i * n + j] = sub(LU.m_[i * n + j], mul(LU.m_[i * n + k], LU.m_[k * n + j])); pivot = -1; for (i = j; i < n; i++) { for (k = 0; k < j; k++) { LU.m_[i * n + j] = sub(LU.m_[i * n + j], mul(LU.m_[i * n + k], LU.m_[k * n + j])); } if (pivot == -1 and neq(*LU.m_[i * n + j], *zero)) pivot = i; } if (pivot == -1) throw SymEngineException("Matrix is rank deficient"); if (pivot - j != 0) { // row must be swapped row_exchange_dense(LU, pivot, j); pl.push_back({pivot, j}); } scale = div(one, LU.m_[j * n + j]); for (i = j + 1; i < n; i++) LU.m_[i * n + j] = mul(LU.m_[i * n + j], scale); } }
// Compute C = A (binary_op) B for CSR matrices that are in the // canonical CSR format. Matrix dimensions of A and B should be the // same. C will be in canonical format as well. void csr_binop_csr_canonical( const CSRMatrix &A, const CSRMatrix &B, CSRMatrix &C, RCP<const Basic>(&bin_op)(const RCP<const Basic> &, const RCP<const Basic> &)) { SYMENGINE_ASSERT(A.row_ == B.row_ and A.col_ == B.col_ and C.row_ == A.row_ and C.col_ == A.col_); // Method that works for canonical CSR matrices C.p_[0] = 0; unsigned nnz = 0; unsigned A_pos, B_pos, A_end, B_end; for (unsigned i = 0; i < A.row_; i++) { A_pos = A.p_[i]; B_pos = B.p_[i]; A_end = A.p_[i + 1]; B_end = B.p_[i + 1]; // while not finished with either row while (A_pos < A_end and B_pos < B_end) { unsigned A_j = A.j_[A_pos]; unsigned B_j = B.j_[B_pos]; if (A_j == B_j) { RCP<const Basic> result = bin_op(A.x_[A_pos], B.x_[B_pos]); if (neq(*result, *zero)) { C.j_.push_back(A_j); C.x_.push_back(result); nnz++; } A_pos++; B_pos++; } else if (A_j < B_j) { RCP<const Basic> result = bin_op(A.x_[A_pos], zero); if (neq(*result, *zero)) { C.j_.push_back(A_j); C.x_.push_back(result); nnz++; } A_pos++; } else { // B_j < A_j RCP<const Basic> result = bin_op(zero, B.x_[B_pos]); if (neq(*result, *zero)) { C.j_.push_back(B_j); C.x_.push_back(result); nnz++; } B_pos++; } } // tail while (A_pos < A_end) { RCP<const Basic> result = bin_op(A.x_[A_pos], zero); if (neq(*result, *zero)) { C.j_.push_back(A.j_[A_pos]); C.x_.push_back(result); nnz++; } A_pos++; } while (B_pos < B_end) { RCP<const Basic> result = bin_op(zero, B.x_[B_pos]); if (neq(*result, *zero)) { C.j_.push_back(B.j_[B_pos]); C.x_.push_back(result); nnz++; } B_pos++; } C.p_[i + 1] = nnz; } // It's enough to check for duplicates as the column indices // remain sorted after the above operations if (CSRMatrix::csr_has_duplicates(C.p_, C.j_, A.row_)) CSRMatrix::csr_sum_duplicates(C.p_, C.j_, C.x_, A.row_); }
RCP<const Basic> pow_expand(const RCP<const Pow> &self) { RCP<const Basic> _base = expand(self->base_); bool negative_pow = false; if (! is_a<Integer>(*self->exp_) || ! is_a<Add>(*_base)) { if (neq(_base, self->base_)) { return pow(_base, self->exp_); } else { return self; } } map_vec_mpz r; int n = rcp_static_cast<const Integer>(self->exp_)->as_int(); if (n < 0) { n = -n; negative_pow = true; } RCP<const Add> base = rcp_static_cast<const Add>(_base); umap_basic_num base_dict = base->dict_; if (! (base->coef_->is_zero())) { // Add the numerical coefficient into the dictionary. This // allows a little bit easier treatment below. insert(base_dict, base->coef_, one); } int m = base_dict.size(); multinomial_coefficients_mpz(m, n, r); umap_basic_num rd; // This speeds up overall expansion. For example for the benchmark // (y + x + z + w)^60 it improves the timing from 135ms to 124ms. rd.reserve(2*r.size()); RCP<const Number> add_overall_coeff=zero; for (auto &p: r) { auto power = p.first.begin(); auto i2 = base_dict.begin(); map_basic_basic d; RCP<const Number> overall_coeff=one; for (; power != p.first.end(); ++power, ++i2) { if (*power > 0) { RCP<const Integer> exp = rcp(new Integer(*power)); RCP<const Basic> base = i2->first; if (is_a<Integer>(*base)) { imulnum(outArg(overall_coeff), rcp_static_cast<const Number>( rcp_static_cast<const Integer>(base)->powint(*exp))); } else if (is_a<Symbol>(*base)) { Mul::dict_add_term(d, exp, base); } else { RCP<const Basic> exp2, t, tmp; tmp = pow(base, exp); if (is_a<Mul>(*tmp)) { for (auto &p: (rcp_static_cast<const Mul>(tmp))->dict_) { Mul::dict_add_term_new(outArg(overall_coeff), d, p.second, p.first); } imulnum(outArg(overall_coeff), (rcp_static_cast<const Mul>(tmp))->coef_); } else { Mul::as_base_exp(tmp, outArg(exp2), outArg(t)); Mul::dict_add_term_new(outArg(overall_coeff), d, exp2, t); } } if (!(i2->second->is_one())) { if (is_a<Integer>(*(i2->second)) || is_a<Rational>(*(i2->second))) { imulnum(outArg(overall_coeff), pownum(i2->second, rcp_static_cast<const Number>(exp))); } else if (is_a<Complex>(*(i2->second))) { RCP<const Number> tmp = rcp_static_cast<const Complex>(i2->second)->pow(*exp); imulnum(outArg(overall_coeff), tmp); } } } } RCP<const Basic> term = Mul::from_dict(overall_coeff, std::move(d)); RCP<const Number> coef2 = rcp(new Integer(p.second)); if (is_a_Number(*term)) { iaddnum(outArg(add_overall_coeff), mulnum(rcp_static_cast<const Number>(term), coef2)); } else { if (is_a<Mul>(*term) && !(rcp_static_cast<const Mul>(term)->coef_->is_one())) { // Tidy up things like {2x: 3} -> {x: 6} imulnum(outArg(coef2), rcp_static_cast<const Mul>(term)->coef_); // We make a copy of the dict_: map_basic_basic d2 = rcp_static_cast<const Mul>(term)->dict_; term = Mul::from_dict(one, std::move(d2)); } Add::dict_add_term(rd, coef2, term); } } RCP<const Basic> result = Add::from_dict(add_overall_coeff, std::move(rd)); if (negative_pow) result = pow(result, minus_one); return result; }
void Conditions::Neq(const string& name, const string& value) { shared_ptr<Condition::Base> neq(new Condition::Neq(name, value)); vector< shared_ptr<Condition::Base> >::push_back(neq); }
void ReactorNet::initialize() { size_t n, nv; char buf[100]; m_nv = 0; m_reactors.clear(); m_nreactors = 0; writelog("Initializing reactor network.\n", m_verbose); if (m_nr == 0) throw CanteraError("ReactorNet::initialize", "no reactors in network!"); size_t sensParamNumber = 0; for (n = 0; n < m_nr; n++) { if (m_r[n]->type() >= ReactorType) { m_r[n]->initialize(m_time); Reactor* r = (Reactor*)m_r[n]; m_reactors.push_back(r); nv = r->neq(); m_size.push_back(nv); m_nparams.push_back(r->nSensParams()); std::vector<std::pair<void*, int> > sens_objs = r->getSensitivityOrder(); for (size_t i = 0; i < sens_objs.size(); i++) { std::map<size_t, size_t>& s = m_sensOrder[sens_objs[i]]; for (std::map<size_t, size_t>::iterator iter = s.begin(); iter != s.end(); ++iter) { m_sensIndex.resize(std::max(iter->second + 1, m_sensIndex.size())); m_sensIndex[iter->second] = sensParamNumber++; } } m_nv += nv; m_nreactors++; if (m_verbose) { sprintf(buf,"Reactor %s: %s variables.\n", int2str(n).c_str(), int2str(nv).c_str()); writelog(buf); sprintf(buf," %s sensitivity params.\n", int2str(r->nSensParams()).c_str()); writelog(buf); } if (m_r[n]->type() == FlowReactorType && m_nr > 1) { throw CanteraError("ReactorNet::initialize", "FlowReactors must be used alone."); } } } m_connect.resize(m_nr*m_nr,0); m_ydot.resize(m_nv,0.0); size_t i, j, nin, nout, nw; ReactorBase* r, *rj; for (i = 0; i < m_nr; i++) { r = m_reactors[i]; for (j = 0; j < m_nr; j++) { if (i == j) { connect(i,j); } else { rj = m_reactors[j]; nin = rj->nInlets(); for (n = 0; n < nin; n++) { if (&rj->inlet(n).out() == r) { connect(i,j); } } nout = rj->nOutlets(); for (n = 0; n < nout; n++) { if (&rj->outlet(n).in() == r) { connect(i,j); } } nw = rj->nWalls(); for (n = 0; n < nw; n++) { if (&rj->wall(n).left() == rj && &rj->wall(n).right() == r) { connect(i,j); } else if (&rj->wall(n).left() == r && &rj->wall(n).right() == rj) { connect(i,j); } } } } } m_atol.resize(neq()); fill(m_atol.begin(), m_atol.end(), m_atols); m_integ->setTolerances(m_rtol, neq(), DATA_PTR(m_atol)); m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens); m_integ->setMaxStepSize(m_maxstep); m_integ->setMaxErrTestFails(m_maxErrTestFails); if (m_verbose) { sprintf(buf, "Number of equations: %s\n", int2str(neq()).c_str()); writelog(buf); sprintf(buf, "Maximum time step: %14.6g\n", m_maxstep); writelog(buf); } m_integ->initialize(m_time, *this); m_init = true; }
static bool loopCond(std::pair<t9, ff::ptr<int>> loopState) { ff::ptr<int> s = ff::snd(loopState); return neq(ff::deref(s), 0); };
bool loopCond(ff::ptr<int> s) { return and(neq(c, ff::deref(s)), neq(ff::deref(s), 0)); };