LMCAS
Lamina Computer Algebra System
载入中...
搜索中...
未找到
LMCAS::anonymous_namespace{differentiation_functions.cpp} 命名空间参考

函数

std::shared_ptr< const SymbolicNode > elementary_outer (const FunctionNode &node, detail::RewriteBudget *budget)
std::shared_ptr< const SymbolicNode > hyperbolic_outer (const FunctionNode &node, detail::RewriteBudget *budget)
std::shared_ptr< const SymbolicNode > inverse_trigonometric_outer (const FunctionNode &node, detail::RewriteBudget *budget)
std::shared_ptr< const SymbolicNode > logarithmic_outer (const FunctionNode &node, detail::RewriteBudget *budget)
std::shared_ptr< const SymbolicNode > special_outer (const FunctionNode &node, detail::RewriteBudget *budget)
std::shared_ptr< const SymbolicNode > trigonometric_outer (const FunctionNode &node, detail::RewriteBudget *budget)
bool valid_log_base (const std::shared_ptr< const SymbolicNode > &base)

函数说明

◆ elementary_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::elementary_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 138 行定义.

139 {
140 const auto& arg = node.arguments()[0];
141 std::shared_ptr<const SymbolicNode> d_outer;
142 switch (node.type()) {
143 case FunctionNode::FuncType::Exp:
144 d_outer = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Exp, node.arguments());
145 break;
146 case FunctionNode::FuncType::Ln:
147 d_outer = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(-1)));
148 break;
149 case FunctionNode::FuncType::Sqrt:
150 d_outer = SymbolicFactory::create_multiply({
151 SymbolicFactory::create_number(Rational(1, 2)),
152 LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(Rational(-1, 2)))
153 }, budget);
154 break;
155 case FunctionNode::FuncType::Abs:
156 {
157 auto abs_arg = LMCAS::detail::make_node<FunctionNode>(
158 FunctionNode::FuncType::Abs, node.arguments());
159 auto abs_inv = LMCAS::detail::make_node<PowerNode>(abs_arg, SymbolicFactory::create_number(BigInt(-1)));
160 d_outer = SymbolicFactory::create_multiply({arg, abs_inv}, budget);
161 }
162 break;
163 default:
164 return nullptr;
165 }
166 budget->measure(d_outer);
167 return d_outer;
168}
LMCAS::FunctionNode::FuncType::Sqrt
@ Sqrt
对数、绝对值、平方根。
定义 functions.hpp:16
LMCAS::SymbolicFactory::create_multiply
static std::shared_ptr< const SymbolicNode > create_multiply(std::vector< std::shared_ptr< const SymbolicNode > > ops, detail::RewriteBudget *budget=nullptr)
创建乘法节点,自动扁平化嵌套乘法并消除单位元.
定义 symbolic_factory.cpp:83
LMCAS::SymbolicFactory::create_number
static std::shared_ptr< const SymbolicNode > create_number(const ::LMCAS::BigInt &v)
定义 symbolic_factory.cpp:7
LMCAS::detail::RewriteBudget::measure
std::size_t measure(const std::shared_ptr< const SymbolicNode > &node)
定义 rewrite_budget.cpp:179
LMCAS::detail::make_node
std::shared_ptr< const Node > make_node(Args &&... args)
定义 base.hpp:123

引用了 LMCAS::FunctionNode::Abs, LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), elementary_outer(), LMCAS::FunctionNode::Exp, LMCAS::FunctionNode::Ln, LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 elementary_outer().

函数调用图:
这是这个函数的调用关系图:

◆ hyperbolic_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::hyperbolic_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 111 行定义.

112 {
113 std::shared_ptr<const SymbolicNode> d_outer;
114 switch (node.type()) {
115 case FunctionNode::FuncType::Sinh:
116 d_outer = LMCAS::detail::make_node<FunctionNode>(
117 FunctionNode::FuncType::Cosh, node.arguments());
118 break;
119 case FunctionNode::FuncType::Cosh:
120 d_outer = LMCAS::detail::make_node<FunctionNode>(
121 FunctionNode::FuncType::Sinh, node.arguments());
122 break;
123 case FunctionNode::FuncType::Tanh:
124 {
125 auto cosh = LMCAS::detail::make_node<FunctionNode>(
126 FunctionNode::FuncType::Cosh, node.arguments());
127 d_outer = LMCAS::detail::make_node<PowerNode>(
128 cosh, SymbolicFactory::create_number(BigInt(-2)));
129 }
130 break;
131 default:
132 return nullptr;
133 }
134 budget->measure(d_outer);
135 return d_outer;
136}

引用了 LMCAS::FunctionNode::Cosh, LMCAS::SymbolicFactory::create_number(), hyperbolic_outer(), LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::FunctionNode::Sinh , 以及 LMCAS::FunctionNode::Tanh.

被这些函数引用 hyperbolic_outer().

函数调用图:
这是这个函数的调用关系图:

◆ inverse_trigonometric_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::inverse_trigonometric_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 60 行定义.

61 {
62 const auto& arg = node.arguments()[0];
63 std::shared_ptr<const SymbolicNode> d_outer;
64 switch (node.type()) {
65 case FunctionNode::FuncType::ArcSin:
66 {
67 auto arg_sq = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(2)));
68 auto neg_arg_sq = SymbolicFactory::create_multiply({
69 SymbolicFactory::create_number(BigInt(-1)), arg_sq
70 }, budget);
71 auto one_minus_sq = SymbolicFactory::create_add({
72 SymbolicFactory::create_number(BigInt(1)), neg_arg_sq
73 }, budget);
74 d_outer = LMCAS::detail::make_node<PowerNode>(
75 one_minus_sq, SymbolicFactory::create_number(Rational(-1, 2)));
76 }
77 break;
78 case FunctionNode::FuncType::ArcCos:
79 {
80 auto arg_sq = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(2)));
81 auto neg_arg_sq = SymbolicFactory::create_multiply({
82 SymbolicFactory::create_number(BigInt(-1)), arg_sq
83 }, budget);
84 auto one_minus_sq = SymbolicFactory::create_add({
85 SymbolicFactory::create_number(BigInt(1)), neg_arg_sq
86 }, budget);
87 auto inv_sqrt = LMCAS::detail::make_node<PowerNode>(
88 one_minus_sq, SymbolicFactory::create_number(Rational(-1, 2)));
89 d_outer = SymbolicFactory::create_multiply({
90 SymbolicFactory::create_number(BigInt(-1)), inv_sqrt
91 }, budget);
92 }
93 break;
94 case FunctionNode::FuncType::ArcTan:
95 {
96 auto arg_sq = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(2)));
97 auto one_plus_sq = SymbolicFactory::create_add({
98 SymbolicFactory::create_number(BigInt(1)), arg_sq
99 }, budget);
100 d_outer = LMCAS::detail::make_node<PowerNode>(
101 one_plus_sq, SymbolicFactory::create_number(BigInt(-1)));
102 }
103 break;
104 default:
105 return nullptr;
106 }
107 budget->measure(d_outer);
108 return d_outer;
109}
LMCAS::SymbolicFactory::create_add
static std::shared_ptr< const SymbolicNode > create_add(std::vector< std::shared_ptr< const SymbolicNode > > ops, detail::RewriteBudget *budget=nullptr)
创建加法节点,自动扁平化嵌套加法并消除零项.
定义 symbolic_factory.cpp:12
LMCAS::Domain::Rational
@ Rational
Rational numbers
定义 assumption.hpp:19

引用了 LMCAS::FunctionNode::ArcCos, LMCAS::FunctionNode::ArcSin, LMCAS::FunctionNode::ArcTan, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), inverse_trigonometric_outer(), LMCAS::detail::make_node() , 以及 LMCAS::detail::RewriteBudget::measure().

被这些函数引用 inverse_trigonometric_outer().

函数调用图:
这是这个函数的调用关系图:

◆ logarithmic_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::logarithmic_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 250 行定义.

251 {
252 const auto& arg = node.arguments()[0];
253 const auto& base = node.arguments()[1];
254 auto ln_base = LMCAS::detail::make_node<FunctionNode>(
255 FunctionNode::FuncType::Ln,
256 std::vector<std::shared_ptr<const SymbolicNode>>{base});
257 return LMCAS::detail::make_node<PowerNode>(
258 SymbolicFactory::create_multiply({arg, ln_base}, budget),
259 SymbolicFactory::create_number(BigInt(-1)));
260}

引用了 LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::FunctionNode::Ln, logarithmic_outer() , 以及 LMCAS::detail::make_node().

被这些函数引用 logarithmic_outer().

函数调用图:
这是这个函数的调用关系图:

◆ special_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::special_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 170 行定义.

171 {
172 const auto& arg = node.arguments()[0];
173 std::shared_ptr<const SymbolicNode> d_outer;
174 switch (node.type()) {
175 case FunctionNode::FuncType::LambertW:
176 {
177 auto W = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::LambertW, node.arguments());
178 auto one = SymbolicFactory::create_number(BigInt(1));
179 auto one_plus_W = SymbolicFactory::create_add({one, W}, budget);
180 auto minus_W = SymbolicFactory::create_multiply({
181 SymbolicFactory::create_number(BigInt(-1)), W}, budget);
182 auto numerator = LMCAS::detail::make_node<FunctionNode>(
183 FunctionNode::FuncType::Exp,
184 std::vector<std::shared_ptr<const SymbolicNode>>{minus_W});
185 auto denominator_inverse = LMCAS::detail::make_node<PowerNode>(
186 one_plus_W, SymbolicFactory::create_number(BigInt(-1)));
187 d_outer = SymbolicFactory::create_multiply({numerator, denominator_inverse}, budget);
188 }
189 break;
190 case FunctionNode::FuncType::Erf:
191 {
192 auto pi = LMCAS::detail::make_node<VariableNode>("pi", true);
193 auto sqrt_pi = LMCAS::detail::make_node<FunctionNode>(
194 FunctionNode::FuncType::Sqrt,
195 std::vector<std::shared_ptr<const SymbolicNode>>{pi});
196 auto sqrt_pi_inv = LMCAS::detail::make_node<PowerNode>(sqrt_pi, SymbolicFactory::create_number(BigInt(-1)));
197 auto two = SymbolicFactory::create_number(BigInt(2));
198 auto neg_one = SymbolicFactory::create_number(BigInt(-1));
199 auto arg_sq = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(2)));
200 auto neg_arg_sq = SymbolicFactory::create_multiply({neg_one, arg_sq}, budget);
201 auto exp_term = LMCAS::detail::make_node<FunctionNode>(
202 FunctionNode::FuncType::Exp,
203 std::vector<std::shared_ptr<const SymbolicNode>>{neg_arg_sq});
204 d_outer = SymbolicFactory::create_multiply({two, sqrt_pi_inv, exp_term}, budget);
205 }
206 break;
207 case FunctionNode::FuncType::Ei:
208 {
209 auto exp_arg = LMCAS::detail::make_node<FunctionNode>(
210 FunctionNode::FuncType::Exp, node.arguments());
211 auto arg_inv = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(-1)));
212 d_outer = SymbolicFactory::create_multiply({exp_arg, arg_inv}, budget);
213 }
214 break;
215 case FunctionNode::FuncType::Si:
216 {
217 auto sin_arg = LMCAS::detail::make_node<FunctionNode>(
218 FunctionNode::FuncType::Sin, node.arguments());
219 auto arg_inv = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(-1)));
220 d_outer = SymbolicFactory::create_multiply({sin_arg, arg_inv}, budget);
221 }
222 break;
223 case FunctionNode::FuncType::Ci:
224 {
225 auto cos_arg = LMCAS::detail::make_node<FunctionNode>(
226 FunctionNode::FuncType::Cos, node.arguments());
227 auto arg_inv = LMCAS::detail::make_node<PowerNode>(arg, SymbolicFactory::create_number(BigInt(-1)));
228 d_outer = SymbolicFactory::create_multiply({cos_arg, arg_inv}, budget);
229 }
230 break;
231 case FunctionNode::FuncType::Li:
232 {
233 auto ln_arg = LMCAS::detail::make_node<FunctionNode>(
234 FunctionNode::FuncType::Ln, node.arguments());
235 d_outer = LMCAS::detail::make_node<PowerNode>(ln_arg, SymbolicFactory::create_number(BigInt(-1)));
236 }
237 break;
238 default:
239 return nullptr;
240 }
241 budget->measure(d_outer);
242 return d_outer;
243}
LMCAS::FunctionNode::FuncType::Si
@ Si
正弦积分 Si(x) = ∫₀ˣ sin(t)/t dt。
定义 functions.hpp:23
LMCAS::FunctionNode::FuncType::Li
@ Li
对数积分 Li(x) = ∫₀ˣ 1/ln(t) dt。
定义 functions.hpp:25
LMCAS::FunctionNode::FuncType::Erf
@ Erf
误差函数 erf(x) = (2/√π)∫₀ˣ e^(-t²) dt。
定义 functions.hpp:21
LMCAS::detail::node
const SymbolicNodePtr & node(const ::LMCAS::SymbolicExpr &expression) noexcept
定义 base.hpp:91
LMCAS::pi
ExprResult pi()
定义 expr_values.cpp:108

引用了 LMCAS::FunctionNode::Ci, LMCAS::FunctionNode::Cos, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::FunctionNode::Ei, LMCAS::FunctionNode::Erf, LMCAS::FunctionNode::Exp, LMCAS::FunctionNode::LambertW, LMCAS::FunctionNode::Li, LMCAS::FunctionNode::Ln, LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::pi(), LMCAS::FunctionNode::Si, LMCAS::FunctionNode::Sin, special_outer() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 special_outer().

函数调用图:
这是这个函数的调用关系图:

◆ trigonometric_outer()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{differentiation_functions.cpp}::trigonometric_outer ( const FunctionNode & node,
detail::RewriteBudget * budget )

在文件 differentiation_functions.cpp 第 7 行定义.

8 {
9 std::shared_ptr<const SymbolicNode> d_outer;
10 switch (node.type()) {
11 case FunctionNode::FuncType::Sin:
12 d_outer = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Cos, node.arguments());
13 break;
14 case FunctionNode::FuncType::Cos:
15 d_outer = SymbolicFactory::create_multiply({
16 SymbolicFactory::create_number(BigInt(-1)),
17 LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Sin, node.arguments())
18 }, budget);
19 break;
20 case FunctionNode::FuncType::Tan:
21 {
22 auto sec = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Sec, node.arguments());
23 d_outer = LMCAS::detail::make_node<PowerNode>(sec, SymbolicFactory::create_number(BigInt(2)));
24 }
25 break;
26 case FunctionNode::FuncType::Cot:
27 {
28 auto csc = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Csc, node.arguments());
29 auto csc_sq = LMCAS::detail::make_node<PowerNode>(csc, SymbolicFactory::create_number(BigInt(2)));
30 d_outer = SymbolicFactory::create_multiply({
31 SymbolicFactory::create_number(BigInt(-1)),
32 csc_sq
33 }, budget);
34 }
35 break;
36 case FunctionNode::FuncType::Sec:
37 {
38 auto sec = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Sec, node.arguments());
39 auto tan = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Tan, node.arguments());
40 d_outer = SymbolicFactory::create_multiply({sec, tan}, budget);
41 }
42 break;
43 case FunctionNode::FuncType::Csc:
44 {
45 auto csc = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Csc, node.arguments());
46 auto cot = LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Cot, node.arguments());
47 d_outer = SymbolicFactory::create_multiply({
48 SymbolicFactory::create_number(BigInt(-1)),
49 csc, cot
50 }, budget);
51 }
52 break;
53 default:
54 return nullptr;
55 }
56 budget->measure(d_outer);
57 return d_outer;
58}
LMCAS::tan
ExprResult tan(const ExprPtr &expression, ComputationContext &context)
定义 expr_elementary.cpp:62

引用了 LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Cot, LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::FunctionNode::Csc, LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::FunctionNode::Sec, LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Tan, LMCAS::tan() , 以及 trigonometric_outer().

被这些函数引用 trigonometric_outer().

函数调用图:
这是这个函数的调用关系图:

◆ valid_log_base()

bool LMCAS::anonymous_namespace{differentiation_functions.cpp}::valid_log_base ( const std::shared_ptr< const SymbolicNode > & base)

在文件 differentiation_functions.cpp 第 245 行定义.

245 {
246 auto number = std::dynamic_pointer_cast<const NumberNode>(base);
247 return number && number->is_positive() && !number->is_one();
248}

引用了 valid_log_base().

被这些函数引用 valid_log_base().

函数调用图:
这是这个函数的调用关系图: