/// <summary>
/// Initializes a new instance of the Rational class,
/// with the provided numerator and denominator order.
/// </summary>
public Rational(
int numeratorOrder,
int denominatorOrder)
{
_numerator = new Polynomial(numeratorOrder);
_denominator = new Polynomial(denominatorOrder);
}
/// <summary>
/// Initializes a new instance of the Rational class,
/// by directly referencing the two provided polynomial coefficients.
/// </summary>
public Rational(
double[] numeratorCoefficients,
double[] denominatorCoefficients)
{
_numerator = new Polynomial(numeratorCoefficients);
_denominator = new Polynomial(denominatorCoefficients);
}
// TODO: Implement polynomial factorization to normalize rationals
/// <summary>
/// Initializes a new instance of the Rational class,
/// by directly referencing the two provided polynomials (no deep copy).
/// </summary>
public Rational(
Polynomial numerator,
Polynomial denominator)
{
_numerator = numerator.Clone();
_denominator = denominator.Clone();
}
Rational(
int numeratorOrder,
int denominatorOrder
)
{
numerator = new Polynomial(numeratorOrder);
denominator = new Polynomial(denominatorOrder);
}
Rational(
Polynomial numerator,
Polynomial denominator
)
{
this.numerator = numerator.Clone();
this.denominator = denominator.Clone();
}
Polynomial(
Polynomial copy
)
{
this.order = copy.order;
this.coefficients = new double[copy.coefficients.Length];
Array.Copy(
copy.coefficients,
this.coefficients,
Math.Min(this.coefficients.Length, copy.coefficients.Length)
);
}
public void TestPolynomial_Additive()
{
Polynomial p1 = new Polynomial(new double[] { -1, 0, 2 });
Polynomial p2 = new Polynomial(new double[] { 4 });
Polynomial p3 = new Polynomial(new double[] { -2, 0, 2 });
Assert.That(p1.Order, Is.EqualTo(2), "P1 Order");
Assert.That(p2.Order, Is.EqualTo(0), "P2 Order");
Assert.That(p3.Order, Is.EqualTo(2), "P3 Order");
Polynomial r1 = p1 + p3;
Assert.That(r1.ToString(), Is.EqualTo("4 x^2 - 3"));
Assert.That(r1.Order, Is.EqualTo(2), "R1 Order");
Polynomial r2 = p1 - p3;
Assert.That(r2.ToString(), Is.EqualTo("1"));
Assert.That(r2.Order, Is.EqualTo(0), "R2 Order");
Polynomial r3 = p1 + (-p3);
Assert.That(r3.ToString(), Is.EqualTo("1"));
Assert.That(r3.Order, Is.EqualTo(0), "R3 Order");
Polynomial r4 = p1 + p2;
Assert.That(r4.ToString(), Is.EqualTo("2 x^2 + 3"));
Assert.That(r4.Order, Is.EqualTo(2), "R4 Order");
Polynomial r5 = p2 + p1;
Assert.That(r5.ToString(), Is.EqualTo("2 x^2 + 3"));
Assert.That(r5.Order, Is.EqualTo(2), "R5 Order");
Polynomial r6 = p1 - (-p2);
Assert.That(r6.ToString(), Is.EqualTo("2 x^2 + 3"));
Assert.That(r6.Order, Is.EqualTo(2), "R6 Order");
Polynomial r7 = p2 - (-p1);
Assert.That(r7.ToString(), Is.EqualTo("2 x^2 + 3"));
Assert.That(r7.Order, Is.EqualTo(2), "R7 Order");
}
public static Polynomial operator- (Polynomial polynomial)
{
Polynomial ret = new Polynomial(polynomial);
ret.NegateInplace();
return ret;
}
public static Polynomial operator- (Polynomial polynomial, double n)
{
Polynomial ret = new Polynomial(polynomial);
ret.SubtractInplace(n);
return ret;
}
public Rational Divide(Polynomial polynomial)
{
return(new Rational(Clone(), polynomial.Clone()));
}
/// <summary>Create a new polynomial by copy</summary>
/// <param name="copy">A polynomial to copy from.</param>
public Polynomial(Polynomial copy)
{
coefficients = new double[copy.coefficients.Length];
SetPolynomial(copy.coefficients);
}
public bool Equals(Polynomial polynomial)
{
return(CompareTo(polynomial) == 0);
}
public void IRID203_PolynomialAddition()
{
Polynomial p1 = new Polynomial(new double[] { -1, 0, 2 });
Polynomial p2 = new Polynomial(new double[] { 4 });
Polynomial a = p1 + p2;
Polynomial b = p2 + p1;
Assert.That(a.ToString(), Is.EqualTo(b.ToString()));
ComplexPolynomial cp1 = new ComplexPolynomial(new Complex[] { -1, 0, 2 });
ComplexPolynomial cp2 = new ComplexPolynomial(new Complex[] { 4 });
ComplexPolynomial ca = cp1 + cp2;
ComplexPolynomial cb = cp2 + cp1;
Assert.That(ca.ToString(), Is.EqualTo(cb.ToString()));
}
/// <remarks>This method operates inplace and thus alters this instance.</remarks>
public void SubtractInplace(Polynomial polynomial)
{
EnsureSupportForOrder(polynomial.Order);
int len = Math.Min(order,polynomial.order)+1;
for(int i=0; i<len; i++)
coefficients[i] -= polynomial.coefficients[i];
}
AddInplace(
Polynomial polynomial
)
{
EnsureSupportForOrder(polynomial.Order);
int len = Math.Min(order, polynomial.order) + 1;
for(int i = 0; i < len; i++)
{
coefficients[i] += polynomial.coefficients[i];
}
}
public Polynomial Multiply(Polynomial polynomial)
{
int orderMin = Math.Min(Order,polynomial.Order);
if(orderMin > 3)
{
int orderMax = Math.Max(Order,polynomial.Order);
this.EnsureSupportForOrder(orderMax);
polynomial.EnsureSupportForOrder(orderMax);
return MultiplyKaratsuba(this.coefficients,polynomial.coefficients,this.order,polynomial.order,SizeOfOrder(orderMax),0);
}
else
{
double[] coeff = new double[1 + Order + polynomial.Order];
for(int i=0;i<=order;i++)
for(int j=0;j<=polynomial.order;j++)
coeff[i+j] += coefficients[i]*polynomial.coefficients[j];
return new Polynomial(coeff);
}
}
operator *(
Polynomial polynomial,
double n
)
{
Polynomial ret = new Polynomial(polynomial);
ret.MultiplyInplace(n);
return ret;
}
public static bool Equals(Polynomial polynomial1, Polynomial polynomial2)
{
return(polynomial1.Equals(polynomial2));
}
/// <summary>
/// Division of two polynomials returning the quotient-with-remainder of the two polynomials given
/// </summary>
/// <param name="a">left polynomial</param>
/// <param name="b">right polynomial</param>
/// <returns>a tuple holding quotient in first and remainder in second</returns>
public static Tuple <Polynomial, Polynomial> DivideLong(Polynomial a, Polynomial b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if (a.Degree <= 0)
{
throw new ArgumentOutOfRangeException("a Degree must be greater than zero");
}
if (b.Degree <= 0)
{
throw new ArgumentOutOfRangeException("b Degree must be greater than zero");
}
if (b.Coeffs[b.Degree - 1] == 0)
{
throw new DivideByZeroException("b polynomial ends with zero");
}
var c1 = a.Coeffs.ToArray();
var c2 = b.Coeffs.ToArray();
var n1 = c1.Length;
var n2 = c2.Length;
double[] quo = null;
double[] rem = null;
if (n2 == 1) // division by scalar
{
var fact = c2[0];
quo = new double[n1];
for (int i = 0; i < n1; i++)
{
quo[i] = c1[i] / fact;
}
rem = new double[] { 0 };
}
else if (n1 < n2) // denominator degree higher than nominator degree
{
// quotient always be 0 and return c1 as remainder
quo = new double[] { 0 };
rem = c1.ToArray();
}
else
{
var dn = n1 - n2;
var scl = c2[n2 - 1];
var c22 = new double[n2 - 1];
for (int ii = 0; ii < c22.Length; ii++)
{
c22[ii] = c2[ii] / scl;
}
int i = dn;
int j = n1 - 1;
while (i >= 0)
{
var v = c1[j];
var vals = new double[j - i];
for (int k = i; k < j; k++)
{
c1[k] -= c22[k - i] * v;
}
i--;
j--;
}
var j1 = j + 1;
var l1 = n1 - j1;
rem = new double[j1];
quo = new double[l1];
for (int k = 0; k < l1; k++)
{
quo[k] = c1[k + j1] / scl;
}
for (int k = 0; k < j1; k++)
{
rem[k] = c1[k];
}
}
if (rem == null)
{
throw new NullReferenceException("resulting remainder was null");
}
if (quo == null)
{
throw new NullReferenceException("resulting quotient was null");
}
// output mapping
var pQuo = new Polynomial(quo);
var pRem = new Polynomial(rem);
pRem.Trim();
pQuo.Trim();
return(new Tuple <Polynomial, Polynomial>(pQuo, pRem));
}
public static Polynomial operator* (double n, Polynomial polynomial)
{
Polynomial ret = new Polynomial(polynomial);
ret.MultiplyInplace(n);
return ret;
}
/// <summary>
/// Create a new rational as the result of dividing a polynomial from this rational.
/// </summary>
/// <param name="polynomial">The polynomial to divide with.</param>
public Rational Divide(Polynomial polynomial)
{
return new Rational(
_numerator.Clone(),
_denominator * polynomial);
}
/// <exception cref="System.DivideByZeroException" />
public static Polynomial operator/ (Polynomial polynomial, double n)
{
Polynomial ret = new Polynomial(polynomial);
ret.DivideInplace(n);
return ret;
}
/// <summary>
/// Invert this rational directly inplace.
/// </summary>
public void InvertInplace()
{
Polynomial temp = _denominator;
_denominator = _numerator;
_numerator = temp;
}
public Polynomial MultiplySlow(Polynomial polynomial)
{
double[] coeff = new double[1 + Order + polynomial.Order];
for(int i=0;i<=order;i++)
for(int j=0;j<=polynomial.order;j++)
coeff[i+j] += coefficients[i]*polynomial.coefficients[j];
return new Polynomial(coeff);
}
/// <summary>
/// Division of two polynomials returning the quotient-with-remainder of the two polynomials given
/// </summary>
/// <param name="b">right polynomial</param>
/// <returns>a tuple holding quotient in first and remainder in second</returns>
public Tuple <Polynomial, Polynomial> DivideLong(Polynomial b)
{
return(DivideLong(this, b));
}
public Rational Divide(Polynomial polynomial)
{
return new Rational(Clone(),polynomial.Clone());
}
public bool Equals(Polynomial polynomial)
{
return CompareTo(polynomial) == 0;
}
/// <summary>
/// Add a polynomial directly inplace to this rational.
/// </summary>
/// <param name="polynomial">The polynomial to add.</param>
public void AddInplace(Polynomial polynomial)
{
_numerator.AddInplace(_denominator * polynomial);
}
public static bool Equals(Polynomial polynomial1, Polynomial polynomial2)
{
return polynomial1.Equals(polynomial2);
}
public int CompareTo(Polynomial polynomial)
{
int i = this.Order;
int j = polynomial.Order;
if(i>j)
return 1;
if(j>i)
return -1;
while(i >= 0)
{
if(this.coefficients[i] > polynomial.coefficients[i])
return 1;
if(this.coefficients[i] < polynomial.coefficients[i])
return -1;
i--;
}
return 0;
}
public static Polynomial operator+ (Polynomial polynomial1, Polynomial polynomial2)
{
Polynomial ret = new Polynomial(polynomial1);
ret.AddInplace(polynomial2);
return ret;
}
/// <summary>
/// Create a new rational as the result of multiplying a polynomial to this rational.
/// </summary>
/// <param name="polynomial">The polynomial to multiply with.</param>
public Rational Multiply(Polynomial polynomial)
{
return new Rational(
_numerator * polynomial,
_denominator.Clone());
}
public static Polynomial operator+ (double n, Polynomial polynomial)
{
Polynomial ret = new Polynomial(polynomial);
ret.AddInplace(n);
return ret;
}
/// <summary>
/// Subtract a polynomial directly inplace from this rational.
/// </summary>
/// <param name="polynomial">The polynomial to subtract.</param>
public void SubtractInplace(Polynomial polynomial)
{
_numerator.SubtractInplace(_denominator * polynomial);
}
public static Polynomial operator- (Polynomial polynomial1, Polynomial polynomial2)
{
Polynomial ret = new Polynomial(polynomial1);
ret.SubtractInplace(polynomial2);
return ret;
}
/// <summary>
/// Initializes a new instance of the Rational class,
/// by deep-copy from an existing rational.
/// </summary>
/// <param name="copy">A rational to copy from.</param>
public Rational(Rational copy)
{
_numerator = new Polynomial(copy._numerator);
_denominator = new Polynomial(copy._denominator);
}
/// <summary>
/// Find all roots of a polynomial by calculating the characteristic polynomial of the companion matrix
/// </summary>
/// <param name="polynomial">The polynomial.</param>
/// <returns>The roots of the polynomial</returns>
public static Complex[] Polynomial(Polynomial polynomial)
{
return(polynomial.Roots());
}
