SimplifierConsole/Demo.txt at master · A1Dmitry/SimplifierConsole · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
--- RICIS Symbolic Engine: Deep Stress Test ---

Test #1: L0: Basic Singularity (10 / (x - 2))
Input:  x => (10 / (x - 2))
Result: x => ∞_{10} when x = 2
--------------------------------------------------
Test #2: L1: Removable Squares ((x^2 - 25)/(x - 5))
Input:  x => ((Pow(x, 2) - 25) / (x - 5))
Result: x => ∞_{0} when x = 5
--------------------------------------------------
Test #3: L2: Coefficients (1 / (2x - 6))
Input:  x => (1 / ((2 * x) - 6))
Result: x => ∞_{1} when x = 3
--------------------------------------------------
Test #4: L3: Quadratic Denom (1 / (x^2 - 4))
Input:  x => (1 / ((x * x) - 4))
Result: x => ∞_{1} when x = 2
--------------------------------------------------
Test #5: L5: Simple Trig (sin(x)/cos(x))
Input:  x => (Sin(x) / Cos(x))
Result: x => ∞_{Sin(x)} when x = 1,5707963267948966
--------------------------------------------------
Test #6: L6: Sinc Function (sin(x) / x)
Input:  x => (Sin(x) / x)
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #7: L7: Composite Trig (tan(2x))
Input:  x => (Sin((2 * x)) / Cos((2 * x)))
Result: x => ∞_{Sin((2 * x))} when x = 0,7853981633974483
--------------------------------------------------
Test #8: L8: Quartic ((x^4 - 1) / (x - 1))
Input:  x => (((((x * x) * x) * x) - 1) / (x - 1))
Result: x => 1
--------------------------------------------------
Test #9: L9: Logarithm (1 / ln(x))
Input:  x => (1 / Log(x))
Result: x => ∞_{1} when x = 1
--------------------------------------------------
Test #10: L10: Exponential removable ((exp(x) - 1)/x)
Input:  x => ((Exp(x) - 1) / x)
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #11: L11: Trig identity ((1 - cos(x))/x²)
Input:  x => ((1 - Cos(x)) / (x * x))
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #12: L12: Tan(x)/x
Input:  x => (Tan(x) / x)
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #13: L13: Navier-Stokes wall analogy (1 / (x*(x+1)))
Input:  x => (1 / (x * (x + 1)))
Result: x => ∞_{1} when x = 0
--------------------------------------------------
Test #14: L14: NS blow-up model (1 / (1 - x²))
Input:  x => (1 / (1 - (x * x)))
Result: x => 1
--------------------------------------------------
Test #15: L15: Essential Singularity (exp(1/z) at z=0)
Input:  x => Exp((1 / x))
Result: x => Exp(∞_{1} when x = 0)
--------------------------------------------------
Test #16: L16: Simple Pole (1/z at z=0)
Input:  x => (1 / x)
Result: x => ∞_{1} when x = 0
--------------------------------------------------
Test #17: L17: Pole of order 2 (1/z² at z=0)
Input:  x => (1 / (x * x))
Result: x => ∞_{1} when x = 0
--------------------------------------------------
Test #18: L18: Logarithmic Singularity (Log(z) at z=0)
Input:  x => Log(x)
Result: x => Log(x) (NO SIMPLIFICATION)
--------------------------------------------------
Test #19: L19: Removable Singularity classic (sin(x)/x at x=0)
Input:  x => (Sin(x) / x)
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #20: L20: Picard Theorem example (exp(1/z) essential)
Input:  x => Exp((1 / x))
Result: x => Exp(∞_{1} when x = 0)
--------------------------------------------------
Test #21: L21: Big Bang model analogy (1/t as t→0+)
Input:  x => (1 / x)
Result: x => ∞_{1} when x = 0
--------------------------------------------------
Test #22: L22: Black Hole Schwarzschild analogy (1/(1 - 2M/r) at r=2M)
Input:  x => (1 / (1 - x))
Result: x => 1
--------------------------------------------------
Test #23: L23: Burgers equation blow-up model (1/(T - t))
Input:  x => (1 / (1 - x))
Result: x => 1
--------------------------------------------------
Test #24: L24: Nested Singularity (x / (x * x))
Input:  x => (x / (x * x))
Result: x => ∞_{0} when x = 0
--------------------------------------------------
Test #25: L25:
Input:  x => ((x * 2) / x)
Result: x => 2
--------------------------------------------------
Test #26: L25: POW
Input:  x => (1 / (Pow(x, 4) - 1))
Result: x => ∞_{1} when x = 1
--------------------------------------------------
=== RICIS Symbolic Engine v7.3 ===

Interactive mode of the 5th stage
Enter an expression with variable x (for example: x => 1 / (x*(x+1)))
Commands: help, exit, quit

RICIS>