@@ -135,6 +135,23 @@ shares a power of `1 - w` with its numerator, and is left to the rules that answ
 | `"csch(c+d*x)/(a-b*sinh(c+d*x)^4)^2".ToEntity().Integrate("x")` | `integral(...)` | 2,511 characters |
 | `"1/((d+k*x^2)*(a+b*x^2+c*x^4)^2)".ToEntity().Integrate("x")` | `integral(...)` | 9,968 characters, in 0.9 s, where before this change master gave 18,154 in 11 s and 10.8 GB |
 
+### A biquadratic with two real roots in `x^2` is integrated by the sign of each root
+
+**Answers where there were none.** Over `a + b x^2 + c x^4`, each root `r` in `x^2` was written `atan(x/sqrt(-r))/sqrt(-r)`.
+Where the discriminant is a positive number times even powers, as `a^2` is, both roots are real, and for a positive
+root that arctangent has an imaginary argument, on its branch cut wherever `x^2 > r`. Each term is now written by the
+sign of its root, as `1/(x^2 - r)` is: the arctangent for a negative root, and `ln((x - sqrt(r))/(x + sqrt(r)))/(2 sqrt(r))`
+for a positive one, with the discriminant's square root taken by halving its powers, so that `4 b^2` gives `2 b` and
+not `2 |b|`. Where the product of the roots is a positive number times even powers too, the roots share a sign, and
+one piecewise holds both terms. Rubi's 7.4.2 `e^(3 acoth(a x)) sqrt(c - c/(a x))/x` had no value between 0 and
+`1/a`, where it is real ([#718](https://github.com/asc-community/AngouriMath/issues/718)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"e^(3*acoth(a*x))*sqrt(c-c/(a*x))/x".ToEntity().Integrate("x")` | `integral(...)` | 3,677 characters, where before this change master gave 1,869 with no value between 0 and `1/a` |
+| `"1/((a-x^2)*(2*a-x^2))".ToEntity().Integrate("x")` | `integral(...)` | 289 characters, by the sign of `a`, where before this change master gave 218 with both arctangents on their cuts past `x^2 = 2 a` |
+| `"x^4/((a-x^2)*(2*a-x^2))".ToEntity().Integrate("x")` | `integral(...)` | 413 characters, where before this change master gave 332 |
+
 ### A polynomial over a symbolic quartic that is two quadratics in a hidden variable is split over them
 
 **Answers where there were none.** `1/(a + b x + c x^2 + b x^3 + a x^4)` was declined, and so were Rubi's 1.3.1
 
@@ -4820,9 +4820,20 @@ private static (Entity[] Polynomial, Entity[] Pole, Entity D, Entity E) SplitOve
         /// </summary>
         private static Entity ArctangentsOverABiquadratic(Entity total, Entity d, Entity e, Entity a, Entity b, Entity c, Entity discriminant, Entity.Variable x)
         {
-            var q = MathS.Sqrt(discriminant);
-            var firstRoot = (-b + q) / (2 * c);
-            var secondRoot = (-b - q) / (2 * c);
+            // Real only over real coefficients: Rubi's 1.1.1.2 `1/((a - i a x)^(3/4) (a + i a x)^(1/4))` comes to a
+            // biquadratic with the imaginary unit in it and a positive discriminant, whose roots are complex,
+            // and the piecewise on their signs had no arm that held -- NaN.
+            var realRoots = SignOfANumberTimesEvenPowers(discriminant) is > 0
+                && !new[] { a, b, c }.Any(coefficient => HoldsTheImaginaryUnit(coefficient.InnerSimplified));
+            // Any square root of the discriminant serves, the other swapping the two roots: of a number times
+            // even powers, the powers halved, since `sqrt(4 b^2)` is `2 |b|`, past which neither root's sign
+            // can be read, where with `2 b` one of `cosh(x)^2/(a + b sech(x))`'s roots is -1.
+            var rootOfTheDiscriminant = realRoots ? ARootOfANumberTimesEvenPowers(discriminant) : null;
+            var q = rootOfTheDiscriminant ?? MathS.Sqrt(discriminant);
+            Entity Root(Entity root) => rootOfTheDiscriminant is not null && !rootOfTheDiscriminant.Nodes.Any(node => node is Powf(_, Number.Rational and not Number.Integer))
+                ? LowestOverTheSymbols(root) : root;
+            var firstRoot = Root((-b + q) / (2 * c));
+            var secondRoot = Root((-b - q) / (2 * c));
             // `1/(x^2 - r)` is `atan(x/s)/s` with `s = sqrt(-r)` for every complex `r` but zero:
             // `d/dx atan(x/s)/s` is `1/(s^2 + x^2)` whatever `s` is, and for a positive `r` the
             // arctangent of an imaginary argument is the hyperbolic one, `-atanh(x/sqrt(r))/sqrt(r)`,
@@ -4831,16 +4842,43 @@ private static Entity ArctangentsOverABiquadratic(Entity total, Entity d, Entity
             // case with real coefficients -- and the two terms then sum to a real function; a
             // piecewise on the sign of a root, as the quadratic rule would write, has no
             // value there at all.
+            // Where the discriminant is a positive number times even powers, both roots are real,
+            // and each term is written by the sign of its root, as the quadratic rule writes
+            // `1/(x^2 - r)`: for a positive `r` and `x^2 > r` the arctangent's argument is on its
+            // cut, the imaginary axis past `i`, where only the sign of a rounding residue decides
+            // its value. Rubi's 7.4.2 `e^(3 acoth(a x)) sqrt(c - c/(a x))/x` comes to
+            // `u^4/((a - u^2)(2 a - u^2))` under `u = sqrt((a x + 1)/x)`, whose discriminant is
+            // `a^2`, and between 0 and `1/a` both arctangents were on their cuts throughout.
+            // And where their product `a/c` is a positive number times even powers too, the two
+            // roots have one sign, that of their sum `-b/c`, and one piecewise on it holds both
+            // terms, where two would combine into four arms, two of which never hold.
+            // https://github.com/asc-community/AngouriMath/issues/718
+            var oneSign = realRoots && SignOfANumberTimesEvenPowers(a / c) is > 0;
+            Entity? arctangents = null, logarithms = null;
             foreach (var (root, sign) in new[] { (firstRoot, 1), (secondRoot, -1) })
             {
                 var coefficient = ((d + e * root) / q).InnerSimplified;
                 if (coefficient == Number.Integer.Zero)
                     continue;
                 var s = MathS.Sqrt(-root);
                 var part = MathS.Arctan(x / s) / s;
-                total += sign == 1 ? coefficient * part : -coefficient * part;
+                if (!realRoots)
+                {
+                    total += sign == 1 ? coefficient * part : -coefficient * part;
+                    continue;
+                }
+                var t = MathS.Sqrt(root);
+                var logarithm = MathS.Ln((x - t) / (x + t)) / (2 * t);
+                var signed = sign == 1 ? coefficient : -coefficient;
+                if (oneSign)
+                {
+                    arctangents = arctangents is null ? signed * part : arctangents + signed * part;
+                    logarithms = logarithms is null ? signed * logarithm : logarithms + signed * logarithm;
+                }
+                else
+                    total += signed * BySign(-root, part, logarithm);
             }
-            return total;
+            return arctangents is not null && logarithms is not null ? total + BySign((b / c).InnerSimplified, arctangents, logarithms) : total;
         }
 
         /// <summary>
@@ -17563,6 +17601,26 @@ private static Entity BySigns(Entity first, Entity second, Entity wherePositiveA
                 (whereNegative, new Lessf(first, Number.Integer.Zero)));
         }
 
+        // A square root of a positive number times even powers of symbols, `sqrt(k)` times each symbol to half
+        // its power; null where the quantity is anything else.
+        private static Entity? ARootOfANumberTimesEvenPowers(Entity quantity)
+        {
+            Entity root = Number.Integer.One;
+            foreach (var factor in Mulf.LinearChildren(quantity.InnerSimplified))
+                switch (factor)
+                {
+                    case Number.Real { IsZero: false, IsNegative: false } number:
+                        root *= MathS.Sqrt(number);
+                        break;
+                    case Powf(Variable symbol, Number.Integer power) when power.EInteger.IsEven && power.EInteger.Sign > 0 && power.EInteger.CanFitInInt32():
+                        root *= WholePower(symbol, power.EInteger.ToInt32Unchecked() / 2);
+                        break;
+                    default:
+                        return null;
+                }
+            return root.InnerSimplified;
+        }
+
         private static int? SignOfANumberTimesEvenPowers(Entity quantity)
         {
             var sign = 1;
 
@@ -0,0 +1,95 @@
+//
+// Copyright (c) 2019-2026 Angouri.
+// AngouriMath is licensed under MIT.
+// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.
+// Website: https://am.angouri.org.
+//
+
+using System;
+using AngouriMath.Extensions;
+using Xunit;
+
+namespace AngouriMath.Tests.Calculus
+{
+    /// <summary>
+    /// Over a biquadratic whose discriminant is a positive number times even powers, both roots in
+    /// <c>x^2</c> are real, and each term is written by the sign of its root: for a positive root
+    /// <c>r</c> the arctangent <c>atan(x/sqrt(-r))</c> has an imaginary argument, on its cut wherever
+    /// <c>x^2 > r</c>. Rubi's 7.4.2 <c>e^(3 acoth(a x)) sqrt(c - c/(a x))/x</c> comes to
+    /// <c>u^4/((a - u^2)(2 a - u^2))</c> under <c>u = sqrt((a x + 1)/x)</c>, and its answer had no value
+    /// between 0 and <c>1/a</c>, where the integrand is real.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/718">#718</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class ABiquadraticWithRealRootsInTheSquareIntegralTest
+    {
+        [Theory]
+        // Rubi 7.4.2:592.
+        [InlineData("e^(3*acoth(a*x))*sqrt(c-c/(a*x))/x", new[] { 0.4, 0.9, 1.6, 2.5, -1.8, -3.1 })]
+        [InlineData("e^(3*acoth(a*x))*sqrt(1-1/(a*x))/x", new[] { 0.4, 0.9, 1.6, 2.5, -1.8, -3.1 })]
+        // Between and beyond the roots of x^2 = a and x^2 = 2 a, 1.14 and 1.61 at a = 1.3.
+        [InlineData("1/((a - x^2)*(2*a - x^2))", new[] { 0.4, 1.4, 2.5, -0.7, -2.2 })]
+        [InlineData("x^4/((a - x^2)*(2*a - x^2))", new[] { 0.4, 1.4, 2.5, -0.7, -2.2 })]
+        public void HasAValueWhereTheIntegrandIsReal(string integrand, double[] points)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            var text = integral.Stringize();
+            Assert.DoesNotContain("integral(", text);
+            Entity Pinned(Entity e) => e.Substitute("a", 0.7).Substitute("c", 1.07);
+            Entity PinnedForTheQuartic(Entity e) => e.Substitute("a", 1.3);
+            Func<Entity, Entity> pin = integrand.Contains("acoth") ? Pinned : PinnedForTheQuartic;
+            var antiderivative = pin(integral.Substitute("C", 0));
+            var derivative = antiderivative.Differentiate("x");
+            var original = pin(integrand.ToEntity());
+            foreach (var at in points)
+            {
+                var want = original.Substitute("x", at).EvalNumerical();
+                Assert.True(Math.Abs((double)want.ImaginaryPart) < 1e-9, $"{integrand} is {want} at x = {at}, which is not a point where it is real");
+                Assert.False(antiderivative.Substitute("x", at).EvalNumerical().IsNaN, $"the antiderivative of {integrand} has no value at x = {at}, where the integrand is {want}");
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                Assert.False(got.IsNaN, $"d/dx of the antiderivative of {integrand} has no value at x = {at}, where the integrand is {want}");
+                Assert.True(Math.Abs((double)(got - want).RealPart) + Math.Abs((double)(got - want).ImaginaryPart)
+                            < 1e-9 * Math.Max(1, Math.Abs((double)want.RealPart)),
+                    $"d/dx of the antiderivative of {integrand} is {got} at x = {at}, where the integrand is {want}");
+            }
+        }
+
+        [Theory]
+        // Rubi 1.1.1.2:1343 and 1359: a biquadratic with the imaginary unit in it and a positive discriminant,
+        // whose roots are not real, keeps its arctangents; split by their signs it had no arm that held.
+        [InlineData("1/((a - i*a*x)^(3/4)*(a + i*a*x)^(1/4))")]
+        [InlineData("(a - i*a*x)^(3/4)/(a + i*a*x)^(7/4)")]
+        public void KeepsItsArctangentsOverComplexCoefficients(string integrand)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            Assert.DoesNotContain("integral(", integral.Stringize());
+            var derivative = integral.Substitute("C", 0).Substitute("a", 1.3).Differentiate("x");
+            var original = integrand.ToEntity().Substitute("a", 1.3);
+            foreach (var at in new[] { -2.2, -0.9, 0.4, 1.4 })
+            {
+                var want = original.Substitute("x", at).EvalNumerical();
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                Assert.False(got.IsNaN, $"d/dx of the antiderivative of {integrand} has no value at x = {at}, where the integrand is {want}");
+                Assert.True(Math.Abs((double)(got - want).RealPart) + Math.Abs((double)(got - want).ImaginaryPart)
+                            < 1e-9 * Math.Max(1, Math.Abs((double)want.RealPart) + Math.Abs((double)want.ImaginaryPart)),
+                    $"d/dx of the antiderivative of {integrand} is {got} at x = {at}, where the integrand is {want}");
+            }
+        }
+
+        [Theory]
+        [InlineData("1/((a - x^2)*(2*a - x^2))")]
+        [InlineData("x^4/((a - x^2)*(2*a - x^2))")]
+        public void IsRealPastBothRoots(string integrand)
+        {
+            // Past both roots each logarithm's argument is positive, and the antiderivative is real;
+            // as arctangents of imaginary arguments it was on their cuts there.
+            var antiderivative = integrand.ToEntity().Integrate("x").Substitute("C", 0).Substitute("a", 1.3);
+            foreach (var at in new[] { 2.5, -2.2 })
+            {
+                var value = antiderivative.Substitute("x", at).EvalNumerical();
+                Assert.False(value.IsNaN, $"the antiderivative of {integrand} has no value at x = {at}");
+                Assert.True(Math.Abs((double)value.ImaginaryPart) < 1e-9, $"the antiderivative of {integrand} is {value} at x = {at}");
+            }
+        }
+    }
+}