public static MultivariatePolynomial Pow(MultivariatePolynomial poly, int exponent)
{
if (exponent < 0)
{
throw new NotImplementedException("Raising a polynomial to a negative exponent not supported.");
}
else if (exponent == 0)
{
return(new MultivariatePolynomial(new Term[] { new Term(1, new Indeterminate[0]) }));
}
else if (exponent == 1)
{
return(poly.Clone());
}
MultivariatePolynomial result = poly.Clone();
int counter = exponent - 1;
while (counter != 0)
{
result = MultivariatePolynomial.Multiply(result, poly);
counter -= 1;
}
return(new MultivariatePolynomial(result.Terms));
}
public static MultivariatePolynomial GetDerivative(MultivariatePolynomial poly, char symbol)
{
List <Term> resultTerms = new List <Term>();
foreach (Term term in poly.Terms)
{
if (term.Variables.Any() && term.Variables.Any(indt => indt.Symbol == symbol))
{
BigInteger newTerm_Coefficient = 0;
List <Indeterminate> newTerm_Variables = new List <Indeterminate>();
foreach (Indeterminate variable in term.Variables)
{
if (variable.Symbol == symbol)
{
newTerm_Coefficient = term.CoEfficient * variable.Exponent;
int newExponent = variable.Exponent - 1;
if (newExponent > 0)
{
newTerm_Variables.Add(new Indeterminate(symbol, newExponent));
}
}
else
{
newTerm_Variables.Add(variable.Clone());
}
}
resultTerms.Add(new Term(newTerm_Coefficient, newTerm_Variables.ToArray()));
}
}
return(new MultivariatePolynomial(resultTerms.ToArray()));
}
public bool Equals(MultivariatePolynomial x, MultivariatePolynomial y)
{
if (x == null)
{
return((y == null) ? true : false);
}
if (!x.Terms.Any())
{
return((!y.Terms.Any()) ? true : false);
}
if (x.Terms.Length != y.Terms.Length)
{
return(false);
}
if (x.Degree != y.Degree)
{
return(false);
}
int index = 0;
foreach (Term term in x.Terms)
{
if (!term.Equals(y.Terms[index++]))
{
return(false);
}
}
return(true);
}
public static MultivariatePolynomial Divide(MultivariatePolynomial left, MultivariatePolynomial right)
{
List <Term> newTermsList = new List <Term>();
List <Term> leftTermsList = CloneHelper <Term> .CloneCollection(left.Terms).ToList();
foreach (Term rightTerm in right.Terms)
{
var matches = leftTermsList.Where(leftTerm => Term.ShareCommonFactor(leftTerm, rightTerm)).ToList();
if (matches.Any())
{
foreach (Term matchTerm in matches)
{
leftTermsList.Remove(matchTerm);
Term quotient = Term.Divide(matchTerm, rightTerm);
if (quotient != Term.Empty)
{
if (!newTermsList.Any(lt => lt.Equals(quotient)))
{
newTermsList.Add(quotient);
}
}
}
}
else
{
///newTermsList.Add(rightTerm);
}
}
MultivariatePolynomial result = new MultivariatePolynomial(newTermsList.ToArray());
return(result);
}
private static MultivariatePolynomial OneToOneArithmetic(MultivariatePolynomial left, MultivariatePolynomial right, Func <Term, Term, Term> operation)
{
List <Term> leftTermsList = CloneHelper <Term> .CloneCollection(left.Terms).ToList();
foreach (Term rightTerm in right.Terms)
{
var match = leftTermsList.Where(leftTerm => Term.AreIdentical(leftTerm, rightTerm));
if (match.Any())
{
Term matchTerm = match.Single();
leftTermsList.Remove(matchTerm);
Term result = operation.Invoke(matchTerm, rightTerm);
if (result.CoEfficient != 0)
{
if (!leftTermsList.Any(lt => lt.Equals(result)))
{
leftTermsList.Add(result);
}
}
}
else
{
if (operation == Term.Subtract)
{
leftTermsList.Add(Term.Negate(rightTerm));
}
else
{
leftTermsList.Add(rightTerm);
}
}
}
return(new MultivariatePolynomial(leftTermsList.ToArray()));
}
public static MultivariatePolynomial Multiply(MultivariatePolynomial left, MultivariatePolynomial right)
{
List <Term> resultTerms = new List <Term>();
foreach (var leftTerm in left.Terms)
{
foreach (var rightTerm in right.Terms)
{
Term newTerm = Term.Multiply(leftTerm, rightTerm);
// Combine like terms
var likeTerms = resultTerms.Where(trm => Term.AreIdentical(newTerm, trm));
if (likeTerms.Any())
{
resultTerms = resultTerms.Except(likeTerms).ToList();
Term likeTermsSum = likeTerms.Aggregate(Term.Add);
Term sum = Term.Add(newTerm, likeTermsSum);
newTerm = sum;
}
// Add new term to resultTerms
resultTerms.Add(newTerm);
}
}
return(new MultivariatePolynomial(resultTerms.ToArray()));
}
public static MultivariatePolynomial GCD(MultivariatePolynomial left, MultivariatePolynomial right)
{
MultivariatePolynomial dividend = left.Clone();
MultivariatePolynomial divisor = right.Clone();
MultivariatePolynomial quotient;
MultivariatePolynomial remainder;
BigInteger dividendLeadingCoefficient = 0;
BigInteger divisorLeadingCoefficient = 0;
bool swap = false;
do
{
swap = false;
dividendLeadingCoefficient = dividend.Terms.Last().CoEfficient;
divisorLeadingCoefficient = divisor.Terms.Last().CoEfficient;
if (dividend.Degree < divisor.Degree)
{
swap = true;
}
else if (dividend.Degree == divisor.Degree && dividendLeadingCoefficient < divisorLeadingCoefficient)
{
swap = true;
}
if (swap)
{
MultivariatePolynomial temp = dividend.Clone();
dividend = divisor;
divisor = temp.Clone();
}
quotient = MultivariatePolynomial.Divide(dividend, divisor);
dividend = quotient.Clone();
}while (BigInteger.Abs(dividendLeadingCoefficient) > 0 && BigInteger.Abs(divisorLeadingCoefficient) > 0 && dividend.HasVariables() && divisor.HasVariables());
if (dividend.HasVariables())
{
return(divisor.Clone());
}
else
{
return(dividend.Clone());
}
}
public static MultivariatePolynomial Product(IEnumerable <MultivariatePolynomial> polys)
{
MultivariatePolynomial result = null;
foreach (MultivariatePolynomial p in polys)
{
if (result == null)
{
result = p.Clone();
}
else
{
result = MultivariatePolynomial.Multiply(result, p);
}
}
return(result);
}
/// <summary>
/// Like the Evaluate method, except it replaces indeterminates with Polynomials instead of integers,
/// and returns the resulting (usually large) Polynomial
/// </summary>
public MultivariatePolynomial FunctionalComposition(List <Tuple <char, MultivariatePolynomial> > indeterminateValues)
{
List <Term> terms = this.Terms.ToList();
List <MultivariatePolynomial> composedTerms = new List <MultivariatePolynomial>();
foreach (Term trm in terms)
{
MultivariatePolynomial constant = MultivariatePolynomial.Parse(trm.CoEfficient.ToString());
List <MultivariatePolynomial> toCompose = new List <MultivariatePolynomial>();
toCompose.Add(constant.Clone());
foreach (Indeterminate variable in trm.Variables)
{
int exp = variable.Exponent;
MultivariatePolynomial valueOfIndeterminate = indeterminateValues.Where(tup => tup.Item1 == variable.Symbol).Select(tup => tup.Item2).FirstOrDefault();
if (valueOfIndeterminate == null)
{
MultivariatePolynomial thisVariableAsPoly = new MultivariatePolynomial(new Term[] { new Term(BigInteger.One, new Indeterminate[] { variable }) });
toCompose.Add(thisVariableAsPoly);
}
else if (exp == 0)
{
continue;
}
else if (exp == 1)
{
toCompose.Add(valueOfIndeterminate);
}
else
{
MultivariatePolynomial toMultiply = MultivariatePolynomial.Pow(valueOfIndeterminate, exp);
toCompose.Add(toMultiply);
}
}
MultivariatePolynomial composed = MultivariatePolynomial.Product(toCompose);
composedTerms.Add(composed);
}
MultivariatePolynomial result = MultivariatePolynomial.Sum(composedTerms);
return(result);
}
public int GetHashCode(MultivariatePolynomial obj)
{
return(obj.GetHashCode());
}
public bool Equals(MultivariatePolynomial other)
{
return(this.Equals(this, other));
}
public static MultivariatePolynomial Subtract(MultivariatePolynomial left, MultivariatePolynomial right)
{
return(OneToOneArithmetic(left, right, Term.Subtract));
}
public static MultivariatePolynomial Add(MultivariatePolynomial left, MultivariatePolynomial right)
{
return(OneToOneArithmetic(left, right, Term.Add));
}
