static public Polynome2D MultiplyXYPolygones(Polynome1D xPolygon, Polynome1D yPolygon) { Polynome2D result = new Polynome2D(); for (int x = 0; x < xPolygon.termCount; x++) { Term1D xTerm = xPolygon.terms[x]; for (int y = 0; y < yPolygon.termCount; y++) { Term1D yTerm = yPolygon.terms[y]; Term2D xyTerm = Term2D.MultiplyXYTerms(xTerm, yTerm); result += xyTerm; } result.AddXTerm(xTerm * yPolygon.constant); } for (int y = 0; y < yPolygon.termCount; y++) { Term1D yTerm = yPolygon.terms[y]; result.AddYTerm(yTerm * xPolygon.constant); } result.m_k = xPolygon.constant * yPolygon.constant; return(result); }
static public Term2D MultiplyXYTerms(Term1D xPolygon, Term1D yPolygon) { Term2D result = new Term2D(); result.m_xPower = xPolygon.power; result.m_yPower = yPolygon.power; result.m_scalar = xPolygon.scalar * yPolygon.scalar; return(result); }
public void AddYTerm(Term1D term) { for (int i = 0; i < m_yTerms.Count; i++) { Term1D yTerm = m_yTerms[i]; if (yTerm.power == term.power) { yTerm += term.scalar; m_yTerms[i] = yTerm; return; } } m_yTerms.Add(term); }
public void AddXTerm(Term1D term) { for (int i = 0; i < m_xTerms.Count; i++) { Term1D xTerm = m_xTerms[i]; if (xTerm.power == term.power) { xTerm += term.scalar; m_xTerms[i] = xTerm; return; } } m_xTerms.Add(term); }
static public Polynome1D LagrangePolynome(List <float> points, int i) { Polynome1D result = new Polynome1D(1); int n = points.Count; for (int j = 0; j < n; j++) { if (j == i) { continue; } float denom = points[i] - points[j]; Term1D term = new Term1D(1, 1 / denom); List <Term1D> terms = new List <Term1D>(); terms.Add(term); Polynome1D polynome = new Polynome1D(terms, -points[j] / denom); result *= polynome; } return(result); }
public void Optimize() { Debug.Log("NOT IMPLEMENTED : Polynome2D.Optimize()"); List <Term1D> xTerms = new List <Term1D>(); List <Term1D> yTerms = new List <Term1D>(); List <Term2D> xyTerms = new List <Term2D>(); List <float> xPowers = new List <float>(); List <float> yPowers = new List <float>(); List <Vector2> xyPowers = new List <Vector2>(); int index; float xPower, yPower; foreach (Term2D xyTerm in m_xyTerms) { xPower = xyTerm.xPower; yPower = xyTerm.yPower; if ((xPower == 0) && (yPower == 0)) { // Cas constante m_k += xyTerm.scalar; } else if (xPower == 0) { // convertir en y seul index = yPowers.IndexOf(yPower); if (index >= 0) { // Présence de duplicatas, que l'on rassemble Term1D presentYTerm = yTerms[index]; presentYTerm += xyTerm.scalar; yTerms[index] = presentYTerm; } else { yPowers.Add(yPower); Term1D term = new Term1D(yPower, xyTerm.scalar); yTerms.Add(term); } } else if (yPower == 0) { // convertir en x seul index = xPowers.IndexOf(xPower); if (index >= 0) { // Présence de duplicatas, que l'on rassemble Term1D presentXTerm = xTerms[index]; presentXTerm += xyTerm.scalar; xTerms[index] = presentXTerm; } else { xPowers.Add(xPower); Term1D term = new Term1D(xPower, xyTerm.scalar); xTerms.Add(term); } } else { Vector2 xyPower = new Vector2(xPower, yPower); index = xyPowers.IndexOf(xyPower); if (index >= 0) { // Présence de duplicatas, que l'on rassemble Term2D presentXTerm = xyTerms[index]; presentXTerm += xyTerm.scalar; xyTerms[index] = presentXTerm; } else { xyPowers.Add(xyPower); xyTerms.Add(xyTerm); } } } foreach (Term1D xTerm in m_xTerms) { xPower = xTerm.power; if (xPower == 0) { // Cas constante m_k += xTerm.scalar; } else { index = xPowers.IndexOf(xPower); if (index >= 0) { // Présence de duplicatas, que l'on rassemble Term1D presentXTerm = xTerms[index]; presentXTerm += xTerm.scalar; xTerms[index] = presentXTerm; } else { xPowers.Add(xPower); xTerms.Add(xTerm); } } } foreach (Term1D yTerm in m_yTerms) { yPower = yTerm.power; if (yPower == 0) { // Cas constante m_k += yTerm.scalar; } else { index = yPowers.IndexOf(yPower); if (index >= 0) { // Présence de duplicatas, que l'on rassemble Term1D presentYTerm = yTerms[index]; presentYTerm += yTerm.scalar; yTerms[index] = presentYTerm; } else { yPowers.Add(yPower); yTerms.Add(yTerm); } } } }
public XMLTerm1D(Term1D term) { m_scalar = term.scalar; m_power = term.power; }