Add C to integration result, change integral node to support range instead of iterations, implement u-substitution and quadratic denominator integral, integration of abs(x), sgn(x) and ln(abs(x))^2

Sources/AngouriMath/Convenience/AngouriMathExtensions.cs

@@ -298,7 +298,7 @@ public static FastExpression Compile(this string str, params Variable[] variable
         /// Finds the symbolical derivative of the given expression
         /// </summary>
         /// <param name="str">
-        /// The expresion to be parsed and differentiated
+        /// The expression to be parsed and differentiated
         /// </param>
         /// <param name="x">
         /// Over which variable to find the derivative
@@ -315,7 +315,7 @@ public static Entity Derive(this string str, Variable x)
         /// Finds the symbolical derivative of the given expression
         /// </summary>
         /// <param name="str">
-        /// The expresion to be parsed and differentiated
+        /// The expression to be parsed and differentiated
         /// </param>
         /// <param name="x">
         /// Over which variable to find the derivative
@@ -328,21 +328,35 @@ public static Entity Differentiate(this string str, Variable x)
             => str.ToEntity().Differentiate(x);
 
         /// <summary>
-        /// Integrates the given expression over the `x` variable, if can.
+        /// Integrates indefinitely the given expression over the `x` variable, if can.
         /// May return an unresolved <see cref="Integralf"/> node.
         /// </summary>
         /// <param name="str">
-        /// The expression to be parsed and integrated over <paramref name="x"/>
+        /// The expression to be parsed and integrated
         /// </param>
-        /// <param name="x">Over which to integrate</param>
+        /// <param name="x">Over which variable to integrate</param>
         /// <returns>
-        /// An integrated expression. It might remain the same,
-        /// it might have no integrals, and it might be transformed so that
-        /// only a few nodes have unresolved integrals.
+        /// An integrated expression. It might remain the same or be transformed into nodes with no integrals.
         /// </returns>
         public static Entity Integrate(this string str, Variable x)
             => str.ToEntity().Integrate(x);
 
+        /// <summary>
+        /// Integrates definitely the given expression over the `x` variable, if can.
+        /// May return an unresolved <see cref="Integralf"/> node.
+        /// </summary>
+        /// <param name="str">
+        /// The expression to be parsed and integrated
+        /// </param>
+        /// <param name="x">Over which variable to integrate</param>
+        /// <param name="from">The lower bound for integrating</param>
+        /// <param name="to">The upper bound for integrating</param>
+        /// <returns>
+        /// An integrated expression. It might remain the same or be transformed into nodes with no integrals.
+        /// </returns>
+        public static Entity Integrate(this string str, Variable x, Entity from, Entity to)
+            => str.ToEntity().Integrate(x, from, to);
+
         /// <summary>
         /// Finds the limit of the given expression over the given variable
         /// </summary>

Sources/AngouriMath/Convenience/MathS.cs

@@ -6338,7 +6338,7 @@ public static Entity Integral(Entity expr, Variable x)
             /// <param name="to">The complex upper bound for integrating</param>
             [Obsolete("Now these functions are available as non-static methods at Entity")]
             public static Complex DefiniteIntegral(Entity expr, Variable x, (EDecimal Re, EDecimal Im) from, (EDecimal Re, EDecimal Im) to) =>
-                Integration.Integrate(expr, x, from, to, 100);
+                DefiniteIntegral(expr, x, from, to, 100);
 
             /// <summary>
             /// Returns a value of a definite integral of a function. Only works for one-variable functions
@@ -6349,7 +6349,7 @@ public static Complex DefiniteIntegral(Entity expr, Variable x, (EDecimal Re, ED
             /// <param name="to">The real upper bound for integrating</param>
             [Obsolete("Now these functions are available as non-static methods at Entity")]
             public static Complex DefiniteIntegral(Entity expr, Variable x, EDecimal from, EDecimal to) =>
-                Integration.Integrate(expr, x, (from, 0), (to, 0), 100);
+                DefiniteIntegral(expr, x, (from, 0), (to, 0), 100);
 
             /// <summary>
             /// Returns a value of a definite integral of a function. Only works for one-variable functions
@@ -6361,7 +6361,7 @@ public static Complex DefiniteIntegral(Entity expr, Variable x, EDecimal from, E
             /// <param name="stepCount">Accuracy (initially, amount of iterations)</param>
             [Obsolete("Now these functions are available as non-static methods at Entity")]
             public static Complex DefiniteIntegral(Entity expr, Variable x, (EDecimal Re, EDecimal Im) from, (EDecimal Re, EDecimal Im) to, int stepCount) =>
-                Integration.Integrate(expr, x, from, to, stepCount);
+                Integration.IntegrateNumerically(expr, x, Complex.Create(from.Re, from.Im), Complex.Create(to.Re, to.Im), stepCount);
 
 
             /// <summary>
@@ -6626,15 +6626,16 @@ public static Complex DefiniteIntegral(Entity expr, Variable x, (EDecimal Re, ED
         /// a
         /// </code>
         /// </example>
-        public static Entity Integral(Entity expr, Entity var) => new Integralf(expr, var, 1);
+        public static Entity Integral(Entity expr, Entity var) => new Integralf(expr, var, null);
 
         /// <summary>
         /// Hangs your entity to an integral node
         /// (to evaluate instead use <see cref="Compute.Integral(Entity, Variable)"/>)
         /// </summary>
         /// <param name="expr">Expression to be hung</param>
         /// <param name="var">Variable over which integral is taken</param>
-        /// <param name="power">Number of times integral is taken. Only integers will be simplified or evaluated.</param>
+        /// <param name="from">The lower bound for integrating</param>
+        /// <param name="to">The upper bound for integrating</param>
         /// <example>
         /// <code>
         /// using System;
@@ -6680,7 +6681,7 @@ public static Complex DefiniteIntegral(Entity expr, Variable x, (EDecimal Re, ED
         /// a
         /// </code>
         /// </example>
-        public static Entity Integral(Entity expr, Entity var, int power) => new Integralf(expr, var, power);
+        public static Entity Integral(Entity expr, Entity var, Entity from, Entity to) => new Integralf(expr, var, (from, to));
 
         /// <summary>
         /// Hangs your entity to a limit node
@@ -6820,6 +6821,18 @@ public static class Boolean
             /// </summary>
             public static Entity.Boolean Create(bool b)
                 => Entity.Boolean.Create(b);
+
+            /// <summary>
+            /// One of the Boolean's states, which also behaves as Entity
+            /// That is, hangable
+            /// </summary>
+            [ConstantField] public static readonly Entity.Boolean True = Entity.Boolean.True;
+
+            /// <summary>
+            /// One of the Boolean's states, which also behaves as Entity
+            /// That is, hangable
+            /// </summary>
+            [ConstantField] public static readonly Entity.Boolean False = Entity.Boolean.False;
         }
 
         /// <summary>

Sources/AngouriMath/Core/Antlr/AngouriMath.g

@@ -1,9 +1,9 @@
 /*
 
-Remember to run the "antlr_rerun.bat" file at the project root every time you modify this file so that other
-source files under the Antlr folder can update and be reflected in other parts of AngouriMath!
-It only consists of commands that are consistent across CMD and Bash so you should be able to run that file
-regardless of whether you are on Windows, Linux or Mac. You need to have an installed Java Runtime, however.
+Remember to run the "antlr_rerun.bat" file located at "Sources/Utils/antlr_rerun.bat" (relative to the repository root)
+every time you modify this file so that the generated source files under the Antlr folder are updated and changes are
+reflected in other parts of AngouriMath. The script only consists of commands that are consistent across CMD and Bash,
+so you should be able to run it on Windows, Linux, or Mac. You need to have an installed Java Runtime, however.
 
 */
 
@@ -362,12 +362,12 @@ atom returns[Entity value]
         }
     | 'integral(' args = function_arguments ')' 
         { 
-            if (Assert("integral", (3, 2), $args.list.Count))
+            if (Assert("integral", (4, 2), $args.list.Count))
             {
-                if ($args.list[2] is Integer { EInteger: var asEInt })
-                    $value = MathS.Integral($args.list[0], $args.list[1], asEInt.ToInt32Checked());
+                if ($args.list.Count == 4)
+                    $value = MathS.Integral($args.list[0], $args.list[1], $args.list[2], $args.list[3]);
                 else
-                    throw new InvalidArgumentParseException("Expected number for the third argument of integral");
+                    $value = MathS.Integral($args.list[0], $args.list[1]);
             }
             else
                 $value = MathS.Integral($args.list[0], $args.list[1]);

Sources/AngouriMath/Core/Antlr/AngouriMathParser.cs

@@ -2968,12 +2968,12 @@ public AtomContext atom() {
 				State = 734;
 				Match(T__39);
 
-				            if (Assert("integral", (3, 2), _localctx.args.list.Count))
+				            if (Assert("integral", (4, 2), _localctx.args.list.Count))
 				            {
-				                if (_localctx.args.list[2] is Integer { EInteger: var asEInt })
-				                    _localctx.value =  MathS.Integral(_localctx.args.list[0], _localctx.args.list[1], asEInt.ToInt32Checked());
+				                if (_localctx.args.list.Count == 4)
+				                    _localctx.value =  MathS.Integral(_localctx.args.list[0], _localctx.args.list[1], _localctx.args.list[2], _localctx.args.list[3]);
 				                else
-				                    throw new InvalidArgumentParseException("Expected number for the third argument of integral");
+				                    _localctx.value =  MathS.Integral(_localctx.args.list[0], _localctx.args.list[1]);
 				            }
 				            else
 				                _localctx.value =  MathS.Integral(_localctx.args.list[0], _localctx.args.list[1]);

Sources/AngouriMath/Core/Entity/Continuous/Entity.Continuous.Calculus.Classes.cs

@@ -12,10 +12,12 @@ namespace AngouriMath
     partial record Entity
     {
 #pragma warning disable CS1591  // only while records' parameters cannot be documented
-        // Iterations should be refactored? to be int instead of Entity
         /// <summary>
         /// A node of derivative
         /// </summary>
+        /// <remarks>
+        /// Negative iterations convert to integrals.
+        /// </remarks>
         public sealed partial record Derivativef(Entity Expression, Entity Var, int Iterations) : CalculusOperator(Expression, Var)
         {
             /// <summary>Reuse the cache by returning the same object if possible</summary>
@@ -32,17 +34,19 @@ public override Entity Replace(Func<Entity, Entity> func) =>
         /// <summary>
         /// A node of integral
         /// </summary>
-        public sealed partial record Integralf(Entity Expression, Entity Var, int Iterations) : CalculusOperator(Expression, Var)
+        public sealed partial record Integralf(Entity Expression, Entity Var, (Entity from, Entity to)? Range) : CalculusOperator(Expression, Var)
         {
             /// <summary>Reuse the cache by returning the same object if possible</summary>
-            private Integralf New(Entity expression, Entity var) =>
+            private Integralf New(Entity expression, Entity var, (Entity from, Entity to)? range) =>
                 ReferenceEquals(Expression, expression) && ReferenceEquals(Var, var)
-                ? this : new(expression, var, Iterations);
+                && (range is null && Range is null || range is var (newFrom, newTo) && Range is var (oldFrom, oldTo)
+                    && ReferenceEquals(newFrom, oldFrom) && ReferenceEquals(newTo, oldTo))
+                ? this : new(expression, var, range);
             /// <inheritdoc/>
             public override Entity Replace(Func<Entity, Entity> func) =>
-                func(New(Expression.Replace(func), Var.Replace(func)));
+                func(New(Expression.Replace(func), Var, Range is var (from, to) ? (from.Replace(func), to.Replace(func)) : null));
             /// <inheritdoc/>
-            protected override Entity[] InitDirectChildren() => new[] { Expression, Var, Iterations };
+            protected override Entity[] InitDirectChildren() => Range is var (from, to) ? [Expression, Var, from, to] : [Expression, Var];
         }
 
         /// <summary>

Sources/AngouriMath/Core/Entity/Discrete/Entity.Discrete.Classes.cs

@@ -20,13 +20,13 @@ partial record Entity
         public sealed partial record Boolean(bool Value) : Statement
         {
             /// <summary>
-            /// One of the Boolean's state, which also behaves as Entity
+            /// One of the Boolean's states, which also behaves as Entity
             /// That is, hangable
             /// </summary>
             [ConstantField] public static readonly Boolean True = new Boolean(true);
 
             /// <summary>
-            /// One of the Boolean's state, which also behaves as Entity
+            /// One of the Boolean's states, which also behaves as Entity
             /// That is, hangable
             /// </summary>
             [ConstantField] public static readonly Boolean False = new Boolean(false);

Sources/AngouriMath/Functions/Continuous/Differentiation.cs

@@ -81,11 +81,15 @@ partial record Matrix
         }
 
         /// <summary>Derives over <paramref name="x"/> <paramref name="power"/> times</summary>
-        public Entity Differentiate(Variable x, EInteger power)
+        public Entity Differentiate(Variable x, int power)
         {
             var ent = this;
-            for (var _ = 0; _ < power; _++)
-                ent = ent.InnerDifferentiate(x);
+            if (power < 0)
+                for (var _ = 0; _ < -power; _++)
+                    ent = ent.Integrate(x);
+            else
+                for (var _ = 0; _ < power; _++)
+                    ent = ent.InnerDifferentiate(x);
             return ent;
         }
 
@@ -276,7 +280,11 @@ partial record Integralf
             /// <inheritdoc/>
             protected override Entity InnerDifferentiate(Variable variable) =>
                 Var == variable
-                ? this with { Iterations = Iterations - 1 }
+                ? Range is var (from, to)
+                  // https://math.stackexchange.com/a/139191/627798
+                  ? to.InnerDifferentiate(variable) * Expression.Substitute(variable, to) -
+                    from.InnerDifferentiate(variable) * Expression.Substitute(variable, from)
+                  : Expression
                 : MathS.Derivative(this, variable, 1);
         }
 #pragma warning restore IDE0054 // Use compound assignment
@@ -303,10 +311,9 @@ protected override Entity InnerDifferentiate(Variable variable)
 
         partial record Absf
         {
-            // TODO: derivative of the absolute function?
             /// <inheritdoc/>
             protected override Entity InnerDifferentiate(Variable variable)
-                => MathS.Signum(Argument) * Argument.InnerDifferentiate(variable);
+                => MathS.Signum(Argument).Provided(!Argument.Equalizes(Integer.Zero)) * Argument.InnerDifferentiate(variable);
         }
 
         partial record Providedf