Loading...
Searching...
No Matches
Public Member Functions | Protected Attributes
SymEngine::DiffVisitor Class Reference
+ Inheritance diagram for SymEngine::DiffVisitor:
+ Collaboration diagram for SymEngine::DiffVisitor:

Public Member Functions

 DiffVisitor (const RCP< const Symbol > &x, bool cache=true)
 
void bvisit (const UnivariateSeries &self)
 
void bvisit (const Max &self)
 
void bvisit (const Min &self)
 
void bvisit (const Number &self)
 
void bvisit (const Constant &self)
 
void bvisit (const Symbol &self)
 
void bvisit (const Log &self)
 
void bvisit (const Abs &self)
 
void bvisit (const ASech &self)
 
void bvisit (const ACoth &self)
 
void bvisit (const ATanh &self)
 
void bvisit (const ACosh &self)
 
void bvisit (const ACsch &self)
 
void bvisit (const ASinh &self)
 
void bvisit (const Coth &self)
 
void bvisit (const Tanh &self)
 
void bvisit (const Sech &self)
 
void bvisit (const Cosh &self)
 
void bvisit (const Csch &self)
 
void bvisit (const Sinh &self)
 
void bvisit (const Subs &self)
 
void bvisit (const Derivative &self)
 
void bvisit (const OneArgFunction &self)
 
void bvisit (const MultiArgFunction &self)
 
void bvisit (const TwoArgFunction &self)
 
void bvisit (const PolyGamma &self)
 
void bvisit (const UpperGamma &self)
 
void bvisit (const LowerGamma &self)
 
void bvisit (const Zeta &self)
 
void bvisit (const LambertW &self)
 
void bvisit (const Add &self)
 
void bvisit (const Mul &self)
 
void bvisit (const Pow &self)
 
void bvisit (const Sin &self)
 
void bvisit (const Cos &self)
 
void bvisit (const Tan &self)
 
void bvisit (const Cot &self)
 
void bvisit (const Csc &self)
 
void bvisit (const Sec &self)
 
void bvisit (const ASin &self)
 
void bvisit (const ACos &self)
 
void bvisit (const ASec &self)
 
void bvisit (const ACsc &self)
 
void bvisit (const ATan &self)
 
void bvisit (const ACot &self)
 
void bvisit (const ATan2 &self)
 
void bvisit (const Erf &self)
 
void bvisit (const Erfc &self)
 
void bvisit (const Gamma &self)
 
void bvisit (const LogGamma &self)
 
void bvisit (const UnevaluatedExpr &self)
 
void bvisit (const UIntPoly &self)
 
void bvisit (const URatPoly &self)
 
void bvisit (const UExprPoly &self)
 
void bvisit (const MIntPoly &self)
 
void bvisit (const MExprPoly &self)
 
void bvisit (const FunctionWrapper &self)
 
void bvisit (const Beta &self)
 
void bvisit (const Set &self)
 
void bvisit (const Tuple &self)
 
void bvisit (const IdentityMatrix &self)
 
void bvisit (const ZeroMatrix &self)
 
void bvisit (const MatrixSymbol &self)
 
void bvisit (const DiagonalMatrix &self)
 
void bvisit (const ImmutableDenseMatrix &self)
 
void bvisit (const MatrixAdd &self)
 
void bvisit (const HadamardProduct &self)
 
void bvisit (const MatrixMul &self)
 
void bvisit (const ConjugateMatrix &self)
 
void bvisit (const Transpose &self)
 
void bvisit (const Trace &self)
 
void bvisit (const Boolean &self)
 
void bvisit (const GaloisField &self)
 
void bvisit (const Piecewise &self)
 
const RCP< const Basic > & apply (const Basic &b)
 
const RCP< const Basic > & apply (const RCP< const Basic > &b)
 

Protected Attributes

const RCP< const Symbol > x
 
RCP< const Basic > result_
 
umap_basic_basic visited
 
bool cache
 

Detailed Description

Definition at line 24 of file derivative.h.

Constructor & Destructor Documentation

◆ DiffVisitor()

SymEngine::DiffVisitor::DiffVisitor ( const RCP< const Symbol > &  x,
bool  cache = true 
)
inline

Definition at line 33 of file derivative.h.

34 : x(x), cache(cache)
35 {
36 }

Member Function Documentation

◆ apply() [1/2]

const RCP< const Basic > & SymEngine::DiffVisitor::apply ( const Basic &  b)

Definition at line 781 of file derivative.cpp.

782{
783 apply(b.rcp_from_this());
784 return result_;
785}

◆ apply() [2/2]

const RCP< const Basic > & SymEngine::DiffVisitor::apply ( const RCP< const Basic > &  b)

Definition at line 787 of file derivative.cpp.

788{
789 if (not cache) {
790 b->accept(*this);
791 return result_;
792 }
793 auto it = visited.find(b);
794 if (it == visited.end()) {
795 b->accept(*this);
796 insert(visited, b, result_);
797 } else {
798 result_ = it->second;
799 }
800 return result_;
801}
std::unordered_map::end
T end(T... args)
std::unordered_map::find
T find(T... args)
SymEngine::insert
void insert(T1 &m, const T2 &first, const T3 &second)
Definition: dict.h:83

◆ bvisit() [1/74]

void SymEngine::DiffVisitor::bvisit ( const Abs &  self)

Definition at line 222 of file derivative.cpp.

223{
224 apply(self.get_arg());
225 if (eq(*result_, *zero)) {
226 result_ = zero;
227 } else {
228 result_ = Derivative::create(self.rcp_from_this(), {x});
229 }
230}
SymEngine::eq
bool eq(const Basic &a, const Basic &b)
Checks equality for a and b
Definition: basic-inl.h:21

◆ bvisit() [2/74]

void SymEngine::DiffVisitor::bvisit ( const ACos &  self)

Definition at line 547 of file derivative.cpp.

548{
549 apply(self.get_arg());
550 result_
551 = mul(div(minus_one, sqrt(sub(one, pow(self.get_arg(), i2)))), result_);
552}
SymEngine::div
RCP< const Basic > div(const RCP< const Basic > &a, const RCP< const Basic > &b)
Division.
Definition: mul.cpp:431
SymEngine::sub
RCP< const Basic > sub(const RCP< const Basic > &a, const RCP< const Basic > &b)
Substracts b from a.
Definition: add.cpp:495
SymEngine::mul
RCP< const Basic > mul(const RCP< const Basic > &a, const RCP< const Basic > &b)
Multiplication.
Definition: mul.cpp:352
std::pow
T pow(T... args)
std::sqrt
T sqrt(T... args)

◆ bvisit() [3/74]

void SymEngine::DiffVisitor::bvisit ( const ACosh &  self)

Definition at line 278 of file derivative.cpp.

279{
280 apply(self.get_arg());
281 result_ = mul(div(one, sqrt(sub(pow(self.get_arg(), i2), one))), result_);
282}

◆ bvisit() [4/74]

void SymEngine::DiffVisitor::bvisit ( const ACot &  self)

Definition at line 578 of file derivative.cpp.

579{
580 apply(self.get_arg());
581 result_ = mul(div(minus_one, add(one, pow(self.get_arg(), i2))), result_);
582}
SymEngine::add
RCP< const Basic > add(const RCP< const Basic > &a, const RCP< const Basic > &b)
Adds two objects (safely).
Definition: add.cpp:425

◆ bvisit() [5/74]

void SymEngine::DiffVisitor::bvisit ( const ACoth &  self)

Definition at line 266 of file derivative.cpp.

267{
268 apply(self.get_arg());
269 result_ = mul(div(one, sub(one, pow(self.get_arg(), i2))), result_);
270}

◆ bvisit() [6/74]

void SymEngine::DiffVisitor::bvisit ( const ACsc &  self)

Definition at line 563 of file derivative.cpp.

564{
565 apply(self.get_arg());
566 result_ = mul(
567 div(minus_one, mul(pow(self.get_arg(), i2),
568 sqrt(sub(one, div(one, pow(self.get_arg(), i2)))))),
569 result_);
570}

◆ bvisit() [7/74]

void SymEngine::DiffVisitor::bvisit ( const ACsch &  self)

Definition at line 284 of file derivative.cpp.

285{
286 apply(self.get_arg());
287 result_ = mul(
288 div(minus_one, mul(sqrt(add(one, div(one, pow(self.get_arg(), i2)))),
289 pow(self.get_arg(), i2))),
290 result_);
291}

◆ bvisit() [8/74]

void SymEngine::DiffVisitor::bvisit ( const Add &  self)

Definition at line 425 of file derivative.cpp.

426{
427 SymEngine::umap_basic_num d;
428 RCP<const Number> coef = zero, coef2;
429 RCP<const Basic> t;
430 for (auto &p : self.get_dict()) {
431 apply(p.first);
432 RCP<const Basic> term = result_;
433 if (is_a<Integer>(*term)
434 && down_cast<const Integer &>(*term).is_zero()) {
435 continue;
436 } else if (is_a_Number(*term)) {
437 iaddnum(outArg(coef),
438 mulnum(p.second, rcp_static_cast<const Number>(term)));
439 } else if (is_a<Add>(*term)) {
440 for (auto &q : (down_cast<const Add &>(*term)).get_dict())
441 Add::dict_add_term(d, mulnum(q.second, p.second), q.first);
442 iaddnum(outArg(coef),
443 mulnum(p.second, down_cast<const Add &>(*term).get_coef()));
444 } else {
445 Add::as_coef_term(mul(p.second, term), outArg(coef2), outArg(t));
446 Add::dict_add_term(d, coef2, t);
447 }
448 }
449 result_ = Add::from_dict(coef, std::move(d));
450}
SymEngine::Add::from_dict
static RCP< const Basic > from_dict(const RCP< const Number > &coef, umap_basic_num &&d)
Create an appropriate instance from dictionary quickly.
Definition: add.cpp:140
SymEngine::Add::dict_add_term
static void dict_add_term(umap_basic_num &d, const RCP< const Number > &coef, const RCP< const Basic > &t)
Adds a new term to the expression.
Definition: add.cpp:237
SymEngine::Add::as_coef_term
static void as_coef_term(const RCP< const Basic > &self, const Ptr< RCP< const Number > > &coef, const Ptr< RCP< const Basic > > &term)
Converts a Basic self into the form of coefficient * term.
Definition: add.cpp:306
std::move
T move(T... args)
SymEngine::is_a_Number
bool is_a_Number(const Basic &b)
Definition: number.h:130
SymEngine::mulnum
RCP< const Number > mulnum(const RCP< const Number > &self, const RCP< const Number > &other)
Multiply self and other
Definition: number.h:93

◆ bvisit() [9/74]

void SymEngine::DiffVisitor::bvisit ( const ASec &  self)

Definition at line 554 of file derivative.cpp.

555{
556 apply(self.get_arg());
557 result_
558 = mul(div(one, mul(pow(self.get_arg(), i2),
559 sqrt(sub(one, div(one, pow(self.get_arg(), i2)))))),
560 result_);
561}

◆ bvisit() [10/74]

void SymEngine::DiffVisitor::bvisit ( const ASech &  self)

Definition at line 258 of file derivative.cpp.

259{
260 apply(self.get_arg());
261 result_ = mul(div(minus_one, mul(sqrt(sub(one, pow(self.get_arg(), i2))),
262 self.get_arg())),
263 result_);
264}

◆ bvisit() [11/74]

void SymEngine::DiffVisitor::bvisit ( const ASin &  self)

Definition at line 541 of file derivative.cpp.

542{
543 apply(self.get_arg());
544 result_ = mul(div(one, sqrt(sub(one, pow(self.get_arg(), i2)))), result_);
545}

◆ bvisit() [12/74]

void SymEngine::DiffVisitor::bvisit ( const ASinh &  self)

Definition at line 293 of file derivative.cpp.

294{
295 apply(self.get_arg());
296 result_ = mul(div(one, sqrt(add(pow(self.get_arg(), i2), one))), result_);
297}

◆ bvisit() [13/74]

void SymEngine::DiffVisitor::bvisit ( const ATan &  self)

Definition at line 572 of file derivative.cpp.

573{
574 apply(self.get_arg());
575 result_ = mul(div(one, add(one, pow(self.get_arg(), i2))), result_);
576}

◆ bvisit() [14/74]

void SymEngine::DiffVisitor::bvisit ( const ATan2 &  self)

Definition at line 584 of file derivative.cpp.

585{
586 apply(div(self.get_num(), self.get_den()));
587 result_ = mul(div(pow(self.get_den(), i2),
588 add(pow(self.get_den(), i2), pow(self.get_num(), i2))),
589 result_);
590}

◆ bvisit() [15/74]

void SymEngine::DiffVisitor::bvisit ( const ATanh &  self)

Definition at line 272 of file derivative.cpp.

273{
274 apply(self.get_arg());
275 result_ = mul(div(one, sub(one, pow(self.get_arg(), i2))), result_);
276}

◆ bvisit() [16/74]

void SymEngine::DiffVisitor::bvisit ( const Beta &  self)

Definition at line 675 of file derivative.cpp.

676{
677 RCP<const Basic> beta_arg0 = self.get_args()[0];
678 RCP<const Basic> beta_arg1 = self.get_args()[1];
679 apply(beta_arg0);
680 RCP<const Basic> diff_beta_arg0 = result_;
681 apply(beta_arg1);
682 RCP<const Basic> diff_beta_arg1 = result_;
683 result_ = mul(self.rcp_from_this(),
684 add(mul(polygamma(zero, beta_arg0), diff_beta_arg0),
685 sub(mul(polygamma(zero, beta_arg1), diff_beta_arg1),
686 mul(polygamma(zero, add(beta_arg0, beta_arg1)),
687 add(diff_beta_arg0, diff_beta_arg1)))));
688}
SymEngine::polygamma
RCP< const Basic > polygamma(const RCP< const Basic > &n_, const RCP< const Basic > &x_)
Canonicalize PolyGamma.
Definition: functions.cpp:3397

◆ bvisit() [17/74]

void SymEngine::DiffVisitor::bvisit ( const Boolean &  self)

Definition at line 755 of file derivative.cpp.

756{
757 throw SymEngineException("Derivative doesn't exist.");
758}

◆ bvisit() [18/74]

void SymEngine::DiffVisitor::bvisit ( const ConjugateMatrix &  self)

Definition at line 740 of file derivative.cpp.

741{
742 throw NotImplementedError("Derivative not implemented");
743}

◆ bvisit() [19/74]

void SymEngine::DiffVisitor::bvisit ( const Constant &  self)

Definition at line 202 of file derivative.cpp.

203{
204 result_ = zero;
205}

◆ bvisit() [20/74]

void SymEngine::DiffVisitor::bvisit ( const Cos &  self)

Definition at line 507 of file derivative.cpp.

508{
509 apply(self.get_arg());
510 result_ = mul(mul(minus_one, sin(self.get_arg())), result_);
511}
SymEngine::sin
RCP< const Basic > sin(const RCP< const Basic > &arg)
Canonicalize Sin:
Definition: functions.cpp:874

◆ bvisit() [21/74]

void SymEngine::DiffVisitor::bvisit ( const Cosh &  self)

Definition at line 319 of file derivative.cpp.

320{
321 apply(self.get_arg());
322 result_ = mul(sinh(self.get_arg()), result_);
323}
SymEngine::sinh
RCP< const Basic > sinh(const RCP< const Basic > &arg)
Canonicalize Sinh:
Definition: functions.cpp:2127

◆ bvisit() [22/74]

void SymEngine::DiffVisitor::bvisit ( const Cot &  self)

Definition at line 520 of file derivative.cpp.

521{
522 apply(self.get_arg());
523 RCP<const Integer> two = integer(2);
524 result_
525 = mul(mul(add(one, pow(cot(self.get_arg()), two)), minus_one), result_);
526}
SymEngine::cot
RCP< const Basic > cot(const RCP< const Basic > &arg)
Canonicalize Cot:
Definition: functions.cpp:1073
SymEngine::integer
std::enable_if< std::is_integral< T >::value, RCP< constInteger > >::type integer(T i)
Definition: integer.h:197

◆ bvisit() [23/74]

void SymEngine::DiffVisitor::bvisit ( const Coth &  self)

Definition at line 299 of file derivative.cpp.

300{
301 apply(self.get_arg());
302 result_ = mul(div(minus_one, pow(sinh(self.get_arg()), i2)), result_);
303}

◆ bvisit() [24/74]

void SymEngine::DiffVisitor::bvisit ( const Csc &  self)

Definition at line 528 of file derivative.cpp.

529{
530 apply(self.get_arg());
531 result_ = mul(mul(mul(cot(self.get_arg()), csc(self.get_arg())), minus_one),
532 result_);
533}
SymEngine::csc
RCP< const Basic > csc(const RCP< const Basic > &arg)
Canonicalize Csc:
Definition: functions.cpp:1138

◆ bvisit() [25/74]

void SymEngine::DiffVisitor::bvisit ( const Csch &  self)

Definition at line 325 of file derivative.cpp.

326{
327 apply(self.get_arg());
328 result_
329 = mul(mul(mul(minus_one, csch(self.get_arg())), coth(self.get_arg())),
330 result_);
331}
SymEngine::coth
RCP< const Basic > coth(const RCP< const Basic > &arg)
Canonicalize Coth:
Definition: functions.cpp:2333
SymEngine::csch
RCP< const Basic > csch(const RCP< const Basic > &arg)
Canonicalize Csch:
Definition: functions.cpp:2169

◆ bvisit() [26/74]

void SymEngine::DiffVisitor::bvisit ( const Derivative &  self)

Definition at line 363 of file derivative.cpp.

364{
365 apply(self.get_arg());
366 RCP<const Basic> ret = result_;
367 if (eq(*ret, *zero)) {
368 result_ = zero;
369 }
370 multiset_basic t = self.get_symbols();
371 for (auto &p : t) {
372 // If x is already there in symbols multi-set add x to the symbols
373 // multi-set
374 if (eq(*p, *x)) {
375 t.insert(x);
376 result_ = Derivative::create(self.get_arg(), t);
377 return;
378 }
379 }
380 // Avoid cycles
381 if (is_a<Derivative>(*ret)
382 && eq(*down_cast<const Derivative &>(*ret).get_arg(),
383 *self.get_arg())) {
384 t.insert(x);
385 result_ = Derivative::create(self.get_arg(), t);
386 return;
387 }
388 for (auto &p : t) {
389 ret = diff(ret, rcp_static_cast<const Symbol>(p));
390 }
391 result_ = ret;
392}
std::multiset::insert
T insert(T... args)

◆ bvisit() [27/74]

void SymEngine::DiffVisitor::bvisit ( const DiagonalMatrix &  self)

Definition at line 715 of file derivative.cpp.

716{
717 throw NotImplementedError("Derivative not implemented");
718}

◆ bvisit() [28/74]

void SymEngine::DiffVisitor::bvisit ( const Erf &  self)

Definition at line 592 of file derivative.cpp.

593{
594 apply(self.get_arg());
595 result_ = mul(
596 div(mul(integer(2), exp(neg(mul(self.get_arg(), self.get_arg())))),
597 sqrt(pi)),
598 result_);
599}
SymEngine::exp
RCP< const Basic > exp(const RCP< const Basic > &x)
Returns the natural exponential function E**x = pow(E, x)
Definition: pow.cpp:271
SymEngine::neg
RCP< const Basic > neg(const RCP< const Basic > &a)
Negation.
Definition: mul.cpp:443

◆ bvisit() [29/74]

void SymEngine::DiffVisitor::bvisit ( const Erfc &  self)

Definition at line 601 of file derivative.cpp.

602{
603 apply(self.get_arg());
604 result_ = neg(
605 mul(div(mul(integer(2), exp(neg(mul(self.get_arg(), self.get_arg())))),
606 sqrt(pi)),
607 result_));
608}

◆ bvisit() [30/74]

void SymEngine::DiffVisitor::bvisit ( const FunctionWrapper &  self)

Definition at line 670 of file derivative.cpp.

671{
672 result_ = self.diff_impl(x);
673}

◆ bvisit() [31/74]

void SymEngine::DiffVisitor::bvisit ( const GaloisField &  self)

Definition at line 760 of file derivative.cpp.

761{
762 GaloisFieldDict d;
763 if (self.get_var()->__eq__(*x)) {
764 d = self.get_poly().gf_diff();
765 result_ = GaloisField::from_dict(self.get_var(), std::move(d));
766 } else {
767 result_ = GaloisField::from_dict(self.get_var(), std::move(d));
768 }
769}

◆ bvisit() [32/74]

void SymEngine::DiffVisitor::bvisit ( const Gamma &  self)

Definition at line 610 of file derivative.cpp.

611{
612 apply(self.get_arg());
613 result_ = mul(mul(self.rcp_from_this(), polygamma(zero, self.get_arg())),
614 result_);
615}

◆ bvisit() [33/74]

void SymEngine::DiffVisitor::bvisit ( const HadamardProduct &  self)

Definition at line 730 of file derivative.cpp.

731{
732 throw NotImplementedError("Derivative not implemented");
733}

◆ bvisit() [34/74]

void SymEngine::DiffVisitor::bvisit ( const IdentityMatrix &  self)

Definition at line 700 of file derivative.cpp.

701{
702 throw NotImplementedError("Derivative not implemented");
703}

◆ bvisit() [35/74]

void SymEngine::DiffVisitor::bvisit ( const ImmutableDenseMatrix &  self)

Definition at line 720 of file derivative.cpp.

721{
722 throw NotImplementedError("Derivative not implemented");
723}

◆ bvisit() [36/74]

void SymEngine::DiffVisitor::bvisit ( const LambertW &  self)

Definition at line 414 of file derivative.cpp.

415{
416 // check http://en.wikipedia.org/wiki/Lambert_W_function#Derivative
417 // for the equation
418 apply(self.get_arg());
419 RCP<const Basic> lambertw_val = lambertw(self.get_arg());
420 result_
421 = mul(div(lambertw_val, mul(self.get_arg(), add(lambertw_val, one))),
422 result_);
423}
SymEngine::lambertw
RCP< const Basic > lambertw(const RCP< const Basic > &arg)
Create a new LambertW instance:
Definition: functions.cpp:1846

◆ bvisit() [37/74]

void SymEngine::DiffVisitor::bvisit ( const Log &  self)

Definition at line 216 of file derivative.cpp.

217{
218 apply(self.get_arg());
219 result_ = mul(div(one, self.get_arg()), result_);
220}

◆ bvisit() [38/74]

void SymEngine::DiffVisitor::bvisit ( const LogGamma &  self)

Definition at line 617 of file derivative.cpp.

618{
619 apply(self.get_arg());
620 result_ = mul(polygamma(zero, self.get_arg()), result_);
621}

◆ bvisit() [39/74]

void SymEngine::DiffVisitor::bvisit ( const LowerGamma &  self)

Definition at line 237 of file derivative.cpp.

238{
239 result_ = fdiff(self, x, *this);
240}

◆ bvisit() [40/74]

void SymEngine::DiffVisitor::bvisit ( const MatrixAdd &  self)

Definition at line 725 of file derivative.cpp.

726{
727 throw NotImplementedError("Derivative not implemented");
728}

◆ bvisit() [41/74]

void SymEngine::DiffVisitor::bvisit ( const MatrixMul &  self)

Definition at line 735 of file derivative.cpp.

736{
737 throw NotImplementedError("Derivative not implemented");
738}

◆ bvisit() [42/74]

void SymEngine::DiffVisitor::bvisit ( const MatrixSymbol &  self)

Definition at line 710 of file derivative.cpp.

711{
712 throw NotImplementedError("Derivative not implemented");
713}

◆ bvisit() [43/74]

void SymEngine::DiffVisitor::bvisit ( const Max &  self)

Definition at line 193 of file derivative.cpp.

◆ bvisit() [44/74]

void SymEngine::DiffVisitor::bvisit ( const MExprPoly &  self)

Definition at line 660 of file derivative.cpp.

661{
662 result_ = diff_mpoly(self, x);
663}

◆ bvisit() [45/74]

void SymEngine::DiffVisitor::bvisit ( const Min &  self)

Definition at line 194 of file derivative.cpp.

◆ bvisit() [46/74]

void SymEngine::DiffVisitor::bvisit ( const MIntPoly &  self)

Definition at line 655 of file derivative.cpp.

656{
657 result_ = diff_mpoly(self, x);
658}

◆ bvisit() [47/74]

void SymEngine::DiffVisitor::bvisit ( const Mul &  self)

Definition at line 452 of file derivative.cpp.

453{
454 RCP<const Number> overall_coef = zero;
455 umap_basic_num add_dict;
456 for (auto &p : self.get_dict()) {
457 RCP<const Number> coef = self.get_coef();
458 apply(pow(p.first, p.second));
459 RCP<const Basic> factor = result_;
460 if (is_a<Integer>(*factor)
461 && down_cast<const Integer &>(*factor).is_zero())
462 continue;
463 map_basic_basic d = self.get_dict();
464 d.erase(p.first);
465 if (is_a_Number(*factor)) {
466 imulnum(outArg(coef), rcp_static_cast<const Number>(factor));
467 } else if (is_a<Mul>(*factor)) {
468 RCP<const Mul> tmp = rcp_static_cast<const Mul>(factor);
469 imulnum(outArg(coef), tmp->get_coef());
470 for (auto &q : tmp->get_dict()) {
471 Mul::dict_add_term_new(outArg(coef), d, q.second, q.first);
472 }
473 } else {
474 RCP<const Basic> exp, t;
475 Mul::as_base_exp(factor, outArg(exp), outArg(t));
476 Mul::dict_add_term_new(outArg(coef), d, exp, t);
477 }
478 if (d.size() == 0) {
479 iaddnum(outArg(overall_coef), coef);
480 } else {
481 RCP<const Basic> mul = Mul::from_dict(one, std::move(d));
482 Add::coef_dict_add_term(outArg(overall_coef), add_dict, coef, mul);
483 }
484 }
485 result_ = Add::from_dict(overall_coef, std::move(add_dict));
486}
SymEngine::Add::coef_dict_add_term
static void coef_dict_add_term(const Ptr< RCP< const Number > > &coef, umap_basic_num &d, const RCP< const Number > &c, const RCP< const Basic > &term)
Updates the numerical coefficient and the dictionary.
Definition: add.cpp:261
SymEngine::Mul::as_base_exp
static void as_base_exp(const RCP< const Basic > &self, const Ptr< RCP< const Basic > > &exp, const Ptr< RCP< const Basic > > &base)
Convert to a base and exponent form.
Definition: mul.cpp:320
SymEngine::Mul::from_dict
static RCP< const Basic > from_dict(const RCP< const Number > &coef, map_basic_basic &&d)
Create a Mul from a dict.
Definition: mul.cpp:115
std::map::erase
T erase(T... args)
SymEngine::factor
int factor(const Ptr< RCP< const Integer > > &f, const Integer &n, double B1)
Definition: ntheory.cpp:370

◆ bvisit() [48/74]

void SymEngine::DiffVisitor::bvisit ( const MultiArgFunction &  self)

Definition at line 409 of file derivative.cpp.

410{
411 result_ = fdiff(self, x, *this);
412}

◆ bvisit() [49/74]

void SymEngine::DiffVisitor::bvisit ( const Number &  self)

Definition at line 197 of file derivative.cpp.

198{
199 result_ = zero;
200}

◆ bvisit() [50/74]

void SymEngine::DiffVisitor::bvisit ( const OneArgFunction &  self)

Definition at line 404 of file derivative.cpp.

405{
406 result_ = fdiff(self, x, *this);
407}

◆ bvisit() [51/74]

void SymEngine::DiffVisitor::bvisit ( const Piecewise &  self)

Definition at line 771 of file derivative.cpp.

772{
773 PiecewiseVec v = self.get_vec();
774 for (auto &p : v) {
775 apply(p.first);
776 p.first = result_;
777 }
778 result_ = piecewise(std::move(v));
779}

◆ bvisit() [52/74]

void SymEngine::DiffVisitor::bvisit ( const PolyGamma &  self)

Definition at line 245 of file derivative.cpp.

246{
247 result_ = fdiff(self, x, *this);
248}

◆ bvisit() [53/74]

void SymEngine::DiffVisitor::bvisit ( const Pow &  self)

Definition at line 488 of file derivative.cpp.

489{
490 if (is_a_Number(*(self.get_exp()))) {
491 apply(self.get_base());
492 result_ = mul(
493 mul(self.get_exp(), pow(self.get_base(), sub(self.get_exp(), one))),
494 result_);
495 } else {
496 apply(mul(self.get_exp(), log(self.get_base())));
497 result_ = mul(self.rcp_from_this(), result_);
498 }
499}
SymEngine::log
RCP< const Basic > log(const RCP< const Basic > &arg)
Returns the Natural Logarithm from argument arg
Definition: functions.cpp:1774

◆ bvisit() [54/74]

void SymEngine::DiffVisitor::bvisit ( const Sec &  self)

Definition at line 535 of file derivative.cpp.

536{
537 apply(self.get_arg());
538 result_ = mul(mul(tan(self.get_arg()), sec(self.get_arg())), result_);
539}
SymEngine::sec
RCP< const Basic > sec(const RCP< const Basic > &arg)
Canonicalize Sec:
Definition: functions.cpp:1202
SymEngine::tan
RCP< const Basic > tan(const RCP< const Basic > &arg)
Canonicalize Tan:
Definition: functions.cpp:1007

◆ bvisit() [55/74]

void SymEngine::DiffVisitor::bvisit ( const Sech &  self)

Definition at line 311 of file derivative.cpp.

312{
313 apply(self.get_arg());
314 result_
315 = mul(mul(mul(minus_one, sech(self.get_arg())), tanh(self.get_arg())),
316 result_);
317}
SymEngine::sech
RCP< const Basic > sech(const RCP< const Basic > &arg)
Canonicalize Sech:
Definition: functions.cpp:2251
SymEngine::tanh
RCP< const Basic > tanh(const RCP< const Basic > &arg)
Canonicalize Tanh:
Definition: functions.cpp:2290

◆ bvisit() [56/74]

void SymEngine::DiffVisitor::bvisit ( const Set &  self)

Definition at line 690 of file derivative.cpp.

691{
692 throw SymEngineException("Derivative doesn't exist.");
693}

◆ bvisit() [57/74]

void SymEngine::DiffVisitor::bvisit ( const Sin &  self)

Definition at line 501 of file derivative.cpp.

502{
503 apply(self.get_arg());
504 result_ = mul(cos(self.get_arg()), result_);
505}
SymEngine::cos
RCP< const Basic > cos(const RCP< const Basic > &arg)
Canonicalize Cos:
Definition: functions.cpp:942

◆ bvisit() [58/74]

void SymEngine::DiffVisitor::bvisit ( const Sinh &  self)

Definition at line 333 of file derivative.cpp.

334{
335 apply(self.get_arg());
336 result_ = mul(cosh(self.get_arg()), result_);
337}
SymEngine::cosh
RCP< const Basic > cosh(const RCP< const Basic > &arg)
Canonicalize Cosh:
Definition: functions.cpp:2212

◆ bvisit() [59/74]

void SymEngine::DiffVisitor::bvisit ( const Subs &  self)

Definition at line 339 of file derivative.cpp.

340{
341 RCP<const Basic> d = zero, t;
342 if (self.get_dict().count(x) == 0) {
343 apply(self.get_arg());
344 d = result_->subs(self.get_dict());
345 }
346 for (const auto &p : self.get_dict()) {
347 apply(p.second);
348 t = result_;
349 if (neq(*t, *zero)) {
350 if (is_a<Symbol>(*p.first)) {
351 d = add(d, mul(t, diff(self.get_arg(),
352 rcp_static_cast<const Symbol>(p.first))
353 ->subs(self.get_dict())));
354 } else {
355 result_ = Derivative::create(self.rcp_from_this(), {x});
356 return;
357 }
358 }
359 }
360 result_ = d;
361}
SymEngine::neq
bool neq(const Basic &a, const Basic &b)
Checks inequality for a and b
Definition: basic-inl.h:29

◆ bvisit() [60/74]

void SymEngine::DiffVisitor::bvisit ( const Symbol &  self)

Definition at line 207 of file derivative.cpp.

208{
209 if (x->get_name() == self.get_name()) {
210 result_ = one;
211 } else {
212 result_ = zero;
213 }
214}

◆ bvisit() [61/74]

void SymEngine::DiffVisitor::bvisit ( const Tan &  self)

Definition at line 513 of file derivative.cpp.

514{
515 apply(self.get_arg());
516 RCP<const Integer> two = integer(2);
517 result_ = mul(add(one, pow(tan(self.get_arg()), two)), result_);
518}

◆ bvisit() [62/74]

void SymEngine::DiffVisitor::bvisit ( const Tanh &  self)

Definition at line 305 of file derivative.cpp.

306{
307 apply(self.get_arg());
308 result_ = mul(sub(one, pow(tanh(self.get_arg()), i2)), result_);
309}

◆ bvisit() [63/74]

void SymEngine::DiffVisitor::bvisit ( const Trace &  self)

Definition at line 750 of file derivative.cpp.

751{
752 throw NotImplementedError("Derivative not implemented");
753}

◆ bvisit() [64/74]

void SymEngine::DiffVisitor::bvisit ( const Transpose &  self)

Definition at line 745 of file derivative.cpp.

746{
747 throw NotImplementedError("Derivative not implemented");
748}

◆ bvisit() [65/74]

void SymEngine::DiffVisitor::bvisit ( const Tuple &  self)

Definition at line 695 of file derivative.cpp.

696{
697 throw NotImplementedError("Derivative not implemented");
698}

◆ bvisit() [66/74]

void SymEngine::DiffVisitor::bvisit ( const TwoArgFunction &  self)

Definition at line 253 of file derivative.cpp.

254{
255 result_ = fdiff(self, x, *this);
256}

◆ bvisit() [67/74]

void SymEngine::DiffVisitor::bvisit ( const UExprPoly &  self)

Definition at line 665 of file derivative.cpp.

666{
667 result_ = diff_upoly<UExprPoly, map_int_Expr>(self, *x);
668}

◆ bvisit() [68/74]

void SymEngine::DiffVisitor::bvisit ( const UIntPoly &  self)

Definition at line 623 of file derivative.cpp.

624{
625 result_ = diff_upoly<UIntPoly, map_uint_mpz>(self, *x);
626}

◆ bvisit() [69/74]

void SymEngine::DiffVisitor::bvisit ( const UnevaluatedExpr &  self)

Definition at line 249 of file derivative.cpp.

250{
251 result_ = Derivative::create(self.rcp_from_this(), {x});
252}

◆ bvisit() [70/74]

void SymEngine::DiffVisitor::bvisit ( const UnivariateSeries &  self)

Definition at line 192 of file derivative.cpp.

◆ bvisit() [71/74]

void SymEngine::DiffVisitor::bvisit ( const UpperGamma &  self)

Definition at line 241 of file derivative.cpp.

242{
243 result_ = fdiff(self, x, *this);
244}

◆ bvisit() [72/74]

void SymEngine::DiffVisitor::bvisit ( const URatPoly &  self)

Definition at line 628 of file derivative.cpp.

629{
630 result_ = diff_upoly<URatPoly, map_uint_mpq>(self, *x);
631}

◆ bvisit() [73/74]

void SymEngine::DiffVisitor::bvisit ( const ZeroMatrix &  self)

Definition at line 705 of file derivative.cpp.

706{
707 throw NotImplementedError("Derivative not implemented");
708}

◆ bvisit() [74/74]

void SymEngine::DiffVisitor::bvisit ( const Zeta &  self)

Definition at line 232 of file derivative.cpp.

233{
234 result_ = fdiff(self, x, *this);
235}

Field Documentation

◆ cache

bool SymEngine::DiffVisitor::cache
protected

Definition at line 30 of file derivative.h.

◆ result_

RCP<const Basic> SymEngine::DiffVisitor::result_
protected

Definition at line 28 of file derivative.h.

◆ visited

umap_basic_basic SymEngine::DiffVisitor::visited
protected

Definition at line 29 of file derivative.h.

◆ x

const RCP<const Symbol> SymEngine::DiffVisitor::x
protected

Definition at line 27 of file derivative.h.

The documentation for this class was generated from the following files:
Generated by Doxygen 1.9.6 and the doxyYoda theme