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)); }