def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
if self.left_arg.is_constant(): return self.const_arg_derivative(self.left_arg, self.right_arg)
if self.right_arg.is_constant(): return self.const_arg_derivative(self.right_arg, self.left_arg)
multiplication_rule = "d/dx f(x)g(x) = f(x) d/dx g(x) + g(x) d/dx f(x)"
left_derivative = self.left_arg.get_derivative()
right_derivative = self.right_arg.get_derivative()
result = addexpr.AdditionExpression(
MultiplicationExpression(self.left_arg, right_derivative.result),
MultiplicationExpression(self.right_arg, left_derivative.result)
)
rule_application = addexpr.AdditionExpression(
MultiplicationExpression(self.left_arg, derivexpr.DerivativeExpression(self.right_arg)),
MultiplicationExpression(self.right_arg, derivexpr.DerivativeExpression(self.left_arg))
)
return Derivative(
self,
result,
rule_application,
[multiplication_rule],
[left_derivative, right_derivative],
)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
sin_rule = "d/dx sin(x) = cos(x)"
derivative = cosexpr.CosExpression(self.arg)
if self.arg == varexpr.VariableExpression():
return Derivative(self, derivative, None, [sin_rule], None)
return utils.apply_chain_rule(self, sin_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
neg_rule = "d/dx (-f(x)) = - d/dx f(x)"
child_derivative = self.arg.get_derivative()
derivative = NegativeExpression(child_derivative.result)
return Derivative(
self, derivative,
NegativeExpression(derivexpr.DerivativeExpression(self.arg)),
[neg_rule], [child_derivative])
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
ln_rule = "d/dx ln(x) = 1/x"
derivative = divexpr.DivisionExpression(
constexpr.ConstantExpression("1"), self.arg)
if self.arg == varexpr.VariableExpression():
return Derivative(self, derivative, None, [ln_rule], None)
return utils.apply_chain_rule(self, ln_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
tan_rule = "d/dx tan(x) = sec^2(x)"
derivative = powexpr.PowerExpression(secexpr.SecExpression(self.arg),
constexpr.ConstantExpression("2"))
if self.arg == varexpr.VariableExpression():
return Derivative(self, derivative, None, [tan_rule], None)
return utils.apply_chain_rule(self, tan_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
sec_rule = "d/dx sec(x) = sec(x)*tan(x)"
derivative = multiexpr.MultiplicationExpression(
SecExpression(self.arg), tanexpr.TanExpression(self.arg))
if self.arg == varexpr.VariableExpression():
return Derivative(self, derivative, None, [sec_rule], None)
return utils.apply_chain_rule(self, sec_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
cos_rule = "d/dx cos(x) = - sin(x)"
derivative = negexpr.NegativeExpression(sinexpr.SinExpression(self.arg))
if self.arg == varexpr.VariableExpression():
return Derivative(
self,
derivative,
None,
[cos_rule],
None
)
return utils.apply_chain_rule(self, cos_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
left_derivative = self.left_arg.get_derivative()
right_derivative = self.right_arg.get_derivative()
rule_application = AdditionExpression(
derivexpr.DerivativeExpression(self.left_arg),
derivexpr.DerivativeExpression(self.right_arg))
applied_rules = ["d/dx (f(x) + g(x)) = d/dx f(x) + d/dx g(x)"]
result = AdditionExpression(left_derivative.result,
right_derivative.result)
child_derivatives = [left_derivative, right_derivative]
return Derivative(self, result, rule_application, applied_rules,
child_derivatives)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
if self.right_arg.is_constant(): return self.const_power_derivative()
if self.left_arg.is_constant(): return self.const_base_derivative()
rule = "d/dx u ^ v = u ^ v * (ln (u) * d/dx v + (v * d/dx u)/ u)"
left_derivative = self.left_arg.get_derivative()
right_derivative = self.right_arg.get_derivative()
result = multiexpr.MultiplicationExpression(
self,
addexpr.AdditionExpression(
multiexpr.MultiplicationExpression(lnexpr.LnExpression(self.left_arg), right_derivative.result),
divexpr.DivisionExpression(
multiexpr.MultiplicationExpression(self.right_arg, left_derivative.result), self.left_arg
)
)
)
rule_application = multiexpr.MultiplicationExpression(
self,
addexpr.AdditionExpression(
multiexpr.MultiplicationExpression(
lnexpr.LnExpression(self.left_arg), derivexpr.DerivativeExpression(self.right_arg)
),
divexpr.DivisionExpression(
multiexpr.MultiplicationExpression(
self.right_arg, derivexpr.DerivativeExpression(self.left_arg)
), self.left_arg
)
)
)
return Derivative(
self,
result,
rule_application,
[rule],
[left_derivative, right_derivative],
)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
sqrt_rule = "d/dx sqrt(x) = 1/(2*sqrt(x))"
derivative = divexpr.DivisionExpression(
constexpr.ConstantExpression("1"),
multiexpr.MultiplicationExpression(constexpr.ConstantExpression("2"), self)
)
if self.arg == varexpr.VariableExpression():
return Derivative(
self,
derivative,
None,
[sqrt_rule],
None
)
return utils.apply_chain_rule(self, sqrt_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
csc_rule = "d/dx csc(x) = -csc(x)*cot(x)"
derivative = multiexpr.MultiplicationExpression(
negexpr.NegativeExpression(
CscExpression(self.arg)
), cotexpr.CotExpression(self.arg)
)
if self.arg == varexpr.VariableExpression():
return Derivative(
self,
derivative,
None,
[csc_rule],
None
)
return utils.apply_chain_rule(self, csc_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
cot_rule = "d/dx cot(x) = -csc^2(x)"
derivative = negexpr.NegativeExpression(
powexpr.PowerExpression(
cscexpr.CscExpression(self.arg), constexpr.ConstantExpression(2)
)
)
if self.arg == varexpr.VariableExpression():
return Derivative(
self,
derivative,
None,
[cot_rule],
None
)
return utils.apply_chain_rule(self, cot_rule, derivative)
def get_derivative(self):
if self.is_constant(): return utils.constant_derivative(self)
if self.right_arg.is_constant(): return self.const_divider_derivative()
rule = "d/dx f(x)/g(x) = (g(x) d/dx f(x) - f(x) d/dx g(x))/(g(x))^2"
left_derivative = self.left_arg.get_derivative()
right_derivative = self.right_arg.get_derivative()
result = DivisionExpression(
subexpr.SubtractionExpression(
multiexpr.MultiplicationExpression(self.right_arg,
left_derivative.result),
multiexpr.MultiplicationExpression(self.left_arg,
right_derivative.result)),
powexpr.PowerExpression(self.right_arg,
constexpr.ConstantExpression("2")))
rule_application = DivisionExpression(
subexpr.SubtractionExpression(
multiexpr.MultiplicationExpression(
self.right_arg,
derivexpr.DerivativeExpression(self.left_arg)),
multiexpr.MultiplicationExpression(
self.left_arg,
derivexpr.DerivativeExpression(self.right_arg))),
powexpr.PowerExpression(self.right_arg,
constexpr.ConstantExpression("2")))
return Derivative(
self,
result,
rule_application,
[rule],
[left_derivative, right_derivative],
)
def get_derivative(self):
return utils.constant_derivative(self)
