public void Equals_PolynomAndNull_False()
{
Polynom a = new Polynom();
Polynom b = null;
Assert.IsFalse(a.Equals(b));
}
public void Add()
{
Polynom polynom1 = new Polynom(coeffPolynom1);
Polynom polynom2 = new Polynom(coeffPolynom2);
Polynom expectedPolynom = new Polynom(coeffAdd);
Assert.That(polynom1 + polynom2, Is.EqualTo(expectedPolynom));
}
public void Clone()
{
Polynom polynom1 = new Polynom(coeffPolynom1);
Polynom polynom2 = (Polynom) polynom1.Clone();
Assert.That(polynom1.Equals(polynom2), Is.True);
Assert.That(ReferenceEquals(polynom1, polynom2), Is.False);
}
public void Mul()
{
Polynom polynom1 = new Polynom(coeffPolynom1);
Polynom polynom2 = new Polynom(coeffPolynom2);
Polynom expectedPolynom = new Polynom(coeffMul);
Assert.That(polynom2 * polynom1, Is.EqualTo(expectedPolynom));
}
public void Equals_EquivalentPolynomials_True()
{
double[] coefficients = new double[] { 1, 2, 3, 4, 5 };
Polynom a = new Polynom(coefficients);
Polynom b = new Polynom(coefficients);
Assert.IsTrue(a.Equals(b));
}
public void Test_GetCoefficients()
{
double[] coefficients = new double[] { 1, 2, 3, 4, 5 };
Polynom polynom = new Polynom(coefficients);
IStructuralEquatable coeff = coefficients;
Assert.IsTrue(coeff.Equals(polynom.GetCoefficients(), StructuralComparisons.StructuralEqualityComparer));
}
public void Equals_InequivalentPolynomials_False()
{
double[] coefficientsA = new double[] { 1, 2, 3, 4, 5 };
double[] coefficientsB = new double[] { 1, 2, 3, 3, 5 };
Polynom a = new Polynom(coefficientsA);
Polynom b = new Polynom(coefficientsB);
Assert.IsFalse(a.Equals(b));
}
public void Constructor_Coefficietn2Degree5_MonomialDgree5()
{
Polynom polynom = new Polynom(2, 5);
double[] expected = new double[] { 0, 0, 0, 0, 0, 2 };
IStructuralEquatable actual = polynom.GetCoefficients();
Assert.IsTrue(actual.Equals(expected, StructuralComparisons.StructuralEqualityComparer));
}
public void Constructor_WithoutParameters_0()
{
Polynom polynom = new Polynom();
double[] expected = new double[] { 0 };
IStructuralEquatable actual = polynom.GetCoefficients();
Assert.IsTrue(actual.Equals(expected, StructuralComparisons.StructuralEqualityComparer));
}
public void EqualsFunction()
{
double[] koeff = new double[a.Degree+1];
for (int i = 0; i < koeff.Length; i++)
{
koeff[i] = a[i];
}
Polynom a1 =new Polynom(koeff);
Assert.IsTrue(a.Equals(a1));
}
static void Main()
{
Polynom p1 = new Polynom(5, 1, 1);
Polynom p2 = new Polynom(1, 1);
Console.WriteLine("P1: {0}", p1);
Console.WriteLine("P2: {0}", p2);
Console.WriteLine("P3: {0}", p1 + p2);
}
public void SubstituteVariableValue()
{
double[] coefficients = new double[] { 1, 2, 3, 4, 5 };
double x = 2;
Polynom polynom = new Polynom(coefficients);
double expected = 129;
double actual = polynom.SubstituteVariableValue(x);
Assert.AreEqual(expected, actual);
}
public void OperatorMultiplicationTest()
{
double[] arr1 = { 1.5, 2.5, 3.5, 4.5 };
double[] arr2 = { 1.5, 2.5 };
Polynom p1 = new Polynom(arr1);
Polynom p2 = new Polynom(arr2);
Polynom p = p1 * p2;
double[] expected = { 2.25, 7.5, 11.5, 15.5, 11.25 };
CollectionAssert.AreEqual(expected, p.Coefficients);
}
public void Test2_NumberPolynom()
{
// arrange
Polynom expected = new Polynom(3, 3, 3, 3);
// act
Polynom p1 = new Polynom(1, 1, 1, 1);
p1 = 3 * p1;
// assert
Assert.AreEqual(expected, p1);
}
static void Main(string[] args)
{
Polynom p1 = new Polynom(1, 2, 3);
Polynom p2 = new Polynom(1, 2, 2);
Polynom p3 = p1 - p2;
/* for(int i = 0; i <= p3.Degree; i++)
* {
* Console.WriteLine(p3[i]);
* }
*/
Console.WriteLine(p1 != p2);
}
public void OperatorDivisionTest()
{
double[] arr1 = { -81, 0, 12, 1 };
double[] arr2 = { 3, 1 };
Polynom p1 = new Polynom(arr1);
Polynom p2 = new Polynom(arr2);
Polynom p = p1 / p2;
double[] expected = { -27, 9, 1 };
CollectionAssert.AreEqual(expected, p.Coefficients);
}
public void Test1_PolynomNumber()
{
// arrange
Polynom expected = new Polynom(2, 2, 2, 2);
// act
Polynom p1 = new Polynom(1, 1, 1, 1);
p1 *= 2;
// assert
Assert.AreEqual(expected, p1);
}
public void OperatorMinusTest()
{
double[] arr1 = { 1.5, 2.5, 3.5, 4.5 };
double[] arr2 = { 1.5, 2.5 };
Polynom p1 = new Polynom(arr1);
Polynom p2 = new Polynom(arr2);
Polynom p = p1 - p2;
double[] expected = { 0.0, 0.0, 3.5, 4.5 };
CollectionAssert.AreEqual(expected, p.Coefficients);
}
static void Main(string[] args)
{
double[] a = { 7, 5, 3 };
var p = new Polynom(a);
// y = 3x^2 + 5x + 7
var y0 = p.Value(0); // 7
var y1 = p.Value(1); // 15
var y5 = p.Value(5); // 107
Console.WriteLine("Конец!");
Console.ReadLine();
}
public override IDualSurfaceCurve[] GetPlaneIntersection(PlaneSurface pl, double umin, double umax, double vmin, double vmax, double precision)
{
if (Precision.IsPerpendicular(pl.Normal, zAxis, false))
{
// two lines along the cylinder axis
Plane lower = new Plane(location, zAxis);
GeoPoint2D sp2d = lower.Project(pl.Location);
GeoVector2D dir2d = lower.Project(pl.Normal).ToLeft();
GeoPoint2D[] ips = Geometry.IntersectLC(sp2d, dir2d, GeoPoint2D.Origin, xAxis.Length);
IDualSurfaceCurve[] res = new IDualSurfaceCurve[ips.Length];
for (int i = 0; i < ips.Length; i++)
{
GeoPoint p = lower.ToGlobal(ips[i]);
Line l3d = Line.TwoPoints(p, p + zAxis);
res[i] = new DualSurfaceCurve(l3d, this, new Line2D(this.PositionOf(l3d.StartPoint), this.PositionOf(l3d.EndPoint)), pl, new Line2D(pl.PositionOf(l3d.StartPoint), pl.PositionOf(l3d.EndPoint)));
}
return(res);
}
else
{
// an ellipse
GeoPoint2D[] cnts = pl.GetLineIntersection(location, zAxis);
if (cnts.Length == 1)
{ // there must be exactly one intersection
GeoPoint cnt = pl.PointAt(cnts[0]);
GeoVector minorAxis = pl.Normal ^ zAxis;
minorAxis.Length = xAxis.Length;
GeoVector majorAxis = minorAxis ^ pl.Normal;
Polynom impl = GetImplicitPolynomial();
Polynom toSolve = impl.Substitute(new Polynom(majorAxis.x, "u", cnt.x, ""), new Polynom(majorAxis.y, "u", cnt.y, ""), new Polynom(majorAxis.z, "u", cnt.z, ""));
double[] roots = toSolve.Roots();
// there must be two roots
majorAxis = roots[0] * majorAxis;
Ellipse elli = Ellipse.Construct();
elli.SetEllipseCenterAxis(cnt, majorAxis, minorAxis);
GeoPoint2D[] fpnts = new GeoPoint2D[5];
for (int i = 0; i < 5; i++)
{
fpnts[i] = PositionOf(elli.PointAt(i / 6.0));
}
Ellipse2D e2d = Ellipse2D.FromFivePoints(fpnts); // there should be a better way to calculate the 2d ellipse, but the following is wrong:
// Ellipse2D e2d = new Ellipse2D(GeoPoint2D.Origin, PositionOf(cnt + majorAxis).ToVector(), PositionOf(cnt + minorAxis).ToVector());
// and principal axis doesn't yield the correct result either
// Geometry.PrincipalAxis(PositionOf(cnt + majorAxis).ToVector(), PositionOf(cnt + minorAxis).ToVector(), out GeoVector2D maj, out GeoVector2D min);
return(new IDualSurfaceCurve[] { new DualSurfaceCurve(elli, this, e2d, pl, pl.GetProjectedCurve(elli, 0.0)) });
}
}
return(new IDualSurfaceCurve[0]);
}
public void Differential_Returns_correct_Polynom()
{
//y = 7 + 5x + 3x^2
var p = new Polynom(7, 5, 3);
const double expected_a0 = 5;
const double expected_a1 = 3 * 2;
// diff_y = 5 + 6x
var diff_p = p.GetDifferential();
Assert.IsNotNull(diff_p);
Assert.AreEqual(expected_a0, diff_p[0]);
Assert.AreEqual(expected_a1, diff_p[1]);
}
public double GetInputPower(int rpm)
{
var x_n = DynamicPerformanceCurves.Select(x => (double)x.Rpm).ToArray();
var y_P = DynamicPerformanceCurves.Select(x => x.PowerInput).ToArray();
if (x_n.Count() != y_P.Count())
{
throw new ArgumentException("Angegebene drehzahlabhängige Leistungsdaten unplausibel.");
}
var p = Polynom.Polyfit(x_n, y_P, 2);
return(p.Polyval(rpm));
}
public Polynom MultiplyWithYield(double[] leftCoeff, double[] rightCoeff)
{
Polynom left = new Polynom(leftCoeff);
Polynom right = new Polynom(rightCoeff);
if (leftCoeff.Length == 1)
{
return leftCoeff[0]*right;
}
if (rightCoeff.Length == 1)
{
return left*rightCoeff[0];
}
return left * right;
}
public void BeginningValues()
{
driver.Navigate().GoToUrl(URL);
Polynom polynom = new Polynom(driver);
Assert.That(polynom.DisplayedTable, Is.True);
Assert.That(polynom.DisplayedFastFunctionInput, Is.True);
Assert.That(polynom.DisplayedVectorPol, Is.True);
Assert.That(polynom.DisplayedFastVectorInput, Is.True);
Assert.That(polynom.DisplayedCriterious, Is.True);
Assert.That(polynom.DisplayedBtnFind, Is.True);
//Assert.That(polynom.TitleResValue(), Is.EqualTo(BEGIN_TITLE_VALUE));
//Assert.That(polynom.PolynomResValue, Is.EqualTo(BEGIN_RES_VALUE));
}
public void Polynoms()
{
RealFunc f = (double x) => 1.0 / (1.0 + x * x);
double a = -9, b = 5;
using (StreamWriter fs = new StreamWriter("Runge.txt"))
{
for (int i = 1; i < 30; i++)
{
Polynom p = Polynom.Lag(f, i - 1, a, b);
fs.WriteLine($"{i} {FuncMethods.RealFuncMethods.NormDistanceС(f,p.Value,a,b)} {FuncMethods.RealFuncMethods.NormDistance(f, p.Value, a, b)}");
}
}
}
public void Level3_PolynomDegree()
{
var a1 = new Polynom()
{
coefficients = new double[] { 5, 8 }
};
var a3 = m.Degree(a1, 3);
Assert.IsTrue(
a3.coefficients[0] == 125 &&
a3.coefficients[1] == 600 &&
a3.coefficients[2] == 960 &&
a3.coefficients[3] == 512);
}
public void PolynomTest05()
{
//arrange
int[] test_array = { 49, -17, 9, 7, 21, -5, -15, -7 };
int[] test_array2 = { -23, 82, 301, -45 };
int[] exp_array = { 26, 65, 310, -38, 21, -5, -15, -7 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 + p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest06()
{
//arrange
int[] test_array = { 49, -17, 9, 7, 21, -5, -15, -7 };
int[] test_array2 = { -23, 82, 301, -45 };
int[] exp_array = { 72, -99, -292, 52, 21, -5, -15, -7 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 - p2;
//assert
Assert.IsTrue(expected == result);
}
private Polynom ReadPolynom(double [] coeffs, int degree)
{
Console.WriteLine("Polinomul introdus:");
Console.WriteLine("");
Complex[] lista = new Complex[degree + 1];
for (int i = 0; i <= degree; ++i)
{
lista[i] = new Complex(coeffs[2 * i], coeffs[2 * i + 1]);
}
Polynom polynom = new Polynom(lista);
return(polynom);
}
public void PolynomTest08()
{
//arrange
int[] test_array = { 2, 0, 0, 0, -7 };
int[] test_array2 = { -113, 822, 3001, -455, -18 };
int[] exp_array = { 115, -822, -3001, 455, 11 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 - p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest10()
{
//arrange
int[] test_array = { 0 };
int[] test_array2 = { 5, -1 };
int[] exp_array = { -5, 1 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 - p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest02()
{
//arrange
int[] test_array = { 9, -5, 78, 19 };
int[] test_array2 = { -9, 0, 7 };
int[] exp_array = { 0, -5, 85, 19 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 + p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest11()
{
//arrange
int[] test_array = { 17, -13, 5, -71 };
int[] test_array2 = { 5, -1, -8, -17, -12, -35 };
int[] exp_array = { 12, -12, 13, -54, 12, 35 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 - p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest03()
{
//arrange
int[] test_array = { 49, -17, 145, 12, 2, 0, -8, 19, -15, -7 };
int[] test_array2 = { -91, -110, 77, 13, -13, -77, 17, 82, 301, -45 };
int[] exp_array = { -42, -127, 222, 25, -11, -77, 9, 101, 286, -52 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 + p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest04()
{
//arrange
int[] test_array = { 49, -17, 145, 12, 2, 0, -8, 19, -15, -7 };
int[] test_array2 = { -13, -77, 17, 82, 301, -45 };
int[] exp_array = { 36, -94, 162, 94, 303, -45, -8, 19, -15, -7 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp_array);
//act
Polynom result = p1 + p2;
//assert
Assert.IsTrue(expected == result);
}
public static List <Polynom[, ]> NOD(Polynom p11, Polynom p22)
{
int[] temp1 = new int[p11.coefficients.Length];
int[] temp2 = new int[p22.coefficients.Length];
p11.coefficients.CopyTo(temp1, 0);
p22.coefficients.CopyTo(temp2, 0);
Polynom p1 = new Polynom(temp1);
Polynom p2 = new Polynom(temp2);
KeyValuePair <Polynom, Polynom> p;
Polynom[,] matrix;
List <Polynom[, ]> polynoms = new List <Polynom[, ]>();
if (p1.degree >= p2.degree)
{
p = p1 / p2;
while (p.Value.degree > 0)
{
matrix = new Polynom[2, 2] {
{ new Polynom(p.Key.coefficients), new Polynom(1) }, { new Polynom(1), new Polynom(0) }
};
polynoms.Add(matrix);
p1 = p2;
p2 = p.Value;
p = p1 / p2;
}
matrix = new Polynom[2, 2] {
{ new Polynom(p.Key.coefficients), new Polynom(1) }, { new Polynom(1), new Polynom(0) }
};
polynoms.Add(matrix);
}
else
{
p = p2 / p1;
while (p.Value.degree > 0)
{
matrix = new Polynom[2, 2] {
{ new Polynom(p.Key.coefficients), new Polynom(1) }, { new Polynom(1), new Polynom(0) }
};
polynoms.Add(matrix);
p2 = p1;
p1 = p.Value;
p = p2 / p1;
}
}
polynoms.Reverse();
return(polynoms);
}
private static Polynom[] GenerateCenteredVector(int centeringModulo, int length)
{
var result = new Polynom[length];
for (int iterVect = 0; iterVect < length; iterVect++)
{
result[iterVect] = new Polynom(512);
for (int iterPoly = 0; iterPoly < 512; iterPoly++)
{
result[iterVect].Coefficients[iterPoly] = GenerateNumberInBoundaries(centeringModulo);
}
}
return(result);
}
public void PolynomTest01()
{
//arrange
int[] test_array = { 7, -3, -5 };
int[] test_array2 = { 9, 5 };
int[] exp = { 63, 8, -60, -25 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp);
//act
Polynom result = p1 * p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest12()
{
//arrange
int[] test_array = { 7, -3, -5, -9, 25, 17, 63, 32, -18, 219, 30, -1 };
int[] test_array2 = { 9, 5, 13, -15, -7, 5, 550, 1, 13, -52, 7 };
int[] exp = { 63, 8, 31, -250, 111, 292, 4982, -1156, -2320, -4000, 14176, 12846, 32811, 14435, -8858, 117848, 15257, 3487, -11125, -40, 262, -7 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp);
//act
Polynom result = p1 * p2;
//assert
Assert.IsTrue(expected == result);
}
public void PolynomTest13()
{
//arrange
int[] test_array = { 9, 5, 1, -71, 13, -52, 7 };
int[] test_array2 = { 0 };
int[] exp = { 0, 0, 0, 0, 0, 0, 0 };
Polynom p1 = new Polynom(test_array);
Polynom p2 = new Polynom(test_array2);
Polynom expected = new Polynom(exp);
//act
Polynom result = p1 * p2;
//assert
Assert.IsTrue(expected == result);
}
public static void GetDiv(List <double> pol1, List <double> pol2, out string result, out string residue)
{
Polynom a = new Polynom();;
Polynom b = new Polynom();
a.SetA(pol1);
b.SetA(pol2);
Polynom res = new Polynom();
Polynom resid = new Polynom();
Divide(a, b, out res, out resid);
result = Show(res);
residue = Show(resid);
}
public override Polynom GetImplicitPolynomial()
{
if (implicitPolynomial == null)
{
PolynomVector w = zAxis ^ (location.ToVector() - PolynomVector.xyz); // the distance of a point to the axis
Polynom l = zAxis * PolynomVector.xyz - zAxis * location.ToVector(); // the distance from location along the axis
//(w*w)/(l*l)==(xAxis*xAxis)/(zAxis*zAxis) == tan(half opening angle)
implicitPolynomial = (w * w) - ((xAxis * xAxis) / (zAxis * zAxis)) * (l * l);
double d1 = implicitPolynomial.Eval(PointAt(new GeoPoint2D(0.5, 0.5)));
double d2 = implicitPolynomial.Eval(PointAt(new GeoPoint2D(10, -10)));
GeoPoint p = PointAt(new GeoPoint2D(1, 0)) + GetNormal(new GeoPoint2D(1, 0)).Normalized; // a point with distance 1 from the cone
double d = implicitPolynomial.Eval(p); // this should be 1
implicitPolynomial = (1 / d) * implicitPolynomial; // OK, this makes a good scaling (but it is not the distance)
}
return(implicitPolynomial);
}
static void Main(string[] args)
{
Function f1 = new SinFunc();
f1.argumentFunction = new Argum();
Function f2 = new CosFunc();
f2.argumentFunction = new ExpFunc();
f2.argumentFunction.argumentFunction = new Argum();
Function f3 = new AddOper(f1, f2);
Console.WriteLine(f1.ToString());
Console.WriteLine(f2.ToString());
Console.WriteLine(f3.ToString());
Console.WriteLine("===========================");
Console.WriteLine("Diff " + f2.ToString() + " = " + f2.Diff().ToString() + "\n");
Console.WriteLine("===========================");
Console.WriteLine("Value " + f2.ToString() + "=" + f2.Diff().ToString() + "\n");
Console.WriteLine("===========================");
string Path = "XMLoutput.xml";
using (StreamWriter sw = new StreamWriter(Path, false, System.Text.Encoding.Default))
{
sw.WriteLine(f2.ToXML());
}
Dictionary <int, double> Coefficients = new Dictionary <int, double>();
Coefficients.Add(0, 2);
Coefficients.Add(1, 7);
Function f4 = new Polynom(f2, Coefficients);
Console.WriteLine(f4.ToString());
Console.WriteLine("===========================");
double val = f2.CalculateCalc(5);
Console.WriteLine(f2.ToString() + "=" + val);
string Path1 = "XMLoutput1.xml";
using (StreamWriter sw = new StreamWriter(Path1, false, System.Text.Encoding.Default))
{
sw.WriteLine(f4.ToXML());
}
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
public double FindRoot(Polynom polynom, double start, double end)
{
const double Eps = 0.000001;
var fstart = polynom.Calculate(start);
while (Math.Abs(start - end) > Eps)
{
var center = (start + end) / 2;
var fcenter = polynom.Calculate(center);
if (fstart * fcenter <= 0)
{
end = center;
}
else
{
start = center;
fstart = fcenter;
}
}
return start;
}
public Lagrange_Polynom(double[,] X_FfromX)
{
Polynom[] l = new Polynom[X_FfromX.Length / 2];
bool l_used;
for (int i = 0; i < l.Length; i++)
{
Polynom tempPoly;
double[] tempDoub = new double[2];
l_used = false;
for (int j = 0; j < l.Length; j++)
{
if (i != j)
{
tempDoub[0] = -1 * X_FfromX[0, j] / (X_FfromX[0, i] - X_FfromX[0, j]);
tempDoub[1] = 1 / (X_FfromX[0, i] - X_FfromX[0, j]);
if (l_used)
{
tempPoly = new Polynom(tempDoub, 2);
l[i] = l[i] * tempPoly;
}
else
{
l_used = true;
l[i] = new Polynom(tempDoub, 2);
}
}
}
l[i] = l[i] * X_FfromX[1, i];
}
Polynom result = l[0];
for (int i = 1; i < l.Length; i++)
{
result = result + l[i];
}
this.coef = result.COEF;
}
static void Main(string[] args)
{
int[] array1 = { 1, 2, 3, 4 };
int[] array2 = { 1, 2, 3, 4 };
// int[] array3 = { 1, 2, 3, 4 };
Polynom p1 = new Polynom(array1,3);
Polynom p2 = new Polynom(array2, 3);
Polynom p3 = p1 + p2;
Console.WriteLine("\n"+"P3=P1+P2");
p3.Show();
Console.WriteLine("\n" + "P1=");
p1.Show();
Console.WriteLine("\n" + "P2=");
p2.Show();
Polynom p4 = p1 - p2;
Console.WriteLine("\n" + "P4=P1-P2");
p4.Show();
Console.WriteLine(Object.Equals(p1, p2));
Console.WriteLine(p1.ToString());
Polynom p5 = p1 * 5;
p5.Show();
Console.ReadKey();
}
public static Polynom operator -(Polynom a, Polynom b)
{
int max = Math.Max(a.coef.Length, b.coef.Length);
Polynom result = new Polynom(max);
for (int i = 0; i < a.coef.Length && i < b.coef.Length; i++)
{
result.coef[i] = a.coef[i] - b.coef[i];
}
return result;
}
public static Polynom operator -(Polynom a, double b)
{
Polynom result = new Polynom(a.coef.Length);
result = result + a;
result.coef[0] -= b;
return result;
}
public static Polynom operator /(Polynom a, double b)
{
Polynom result = new Polynom(a.coef.Length);
result = result + a;
for (int i = 0; i < result.coef.Length; i++)
result.coef[i] /= b;
return result;
}
public void EditCoef(int coefficient, double data)
{
if (coefficient > coef.Length)
{
Polynom a = new Polynom(coefficient);
a = a + this;
a.EditCoef(coefficient, data);
this.coef = a.coef;
}
else
this.coef[coefficient] = data;
}
private static Polynom MultiplyGeneratorPolynomByLeadterm(Polynom genPolynom, PolynomItem leadTerm, int lowerExponentBy)
{
var resultPolynom = new Polynom();
foreach (var polItemRes in genPolynom.PolyItems.Select(polItemBase => new PolynomItem
{
Coefficient = (polItemBase.Coefficient + leadTerm.Coefficient)%255,
Exponent = polItemBase.Exponent - lowerExponentBy
}))
{
resultPolynom.PolyItems.Add(polItemRes);
}
return resultPolynom;
}
private Polynom ConvertToDecNotation(Polynom poly)
{
var newPoly = new Polynom();
for (var i = 0; i < poly.PolyItems.Count; i++)
newPoly.PolyItems.Add(new PolynomItem(this.GetIntValFromAlphaExp(poly.PolyItems[i].Coefficient), poly.PolyItems[i].Exponent));
return newPoly;
}
private Polynom MultiplyAlphaPolynoms(Polynom polynomBase, Polynom polynomMultiplier)
{
var resultPolynom = new Polynom();
foreach (var polItemRes in polynomMultiplier.PolyItems.SelectMany(polItemBase => polynomBase.PolyItems.Select(polItemMulti => new PolynomItem
{
Coefficient = ShrinkAlphaExp(polItemBase.Coefficient + polItemMulti.Coefficient),
Exponent = (polItemBase.Exponent + polItemMulti.Exponent)
})))
{
resultPolynom.PolyItems.Add(polItemRes);
}
var exponentsToGlue = resultPolynom.PolyItems.GroupBy(x => x.Exponent).Where(x => x.Count() > 1).Select(x => x.First().Exponent);
var gluedPolynoms = new List<PolynomItem>();
foreach (var exponent in exponentsToGlue)
{
var polynomFixed = new PolynomItem {Exponent = exponent};
var coefficient = resultPolynom.PolyItems.Where(x => x.Exponent == exponent).Aggregate(0, (current, polynomOld) => current ^ GetIntValFromAlphaExp(polynomOld.Coefficient));
polynomFixed.Coefficient = GetAlphaExpFromIntVal(coefficient);
gluedPolynoms.Add(polynomFixed);
}
resultPolynom.PolyItems.RemoveAll(x => exponentsToGlue.Contains(x.Exponent));
resultPolynom.PolyItems.AddRange(gluedPolynoms);
resultPolynom.PolyItems = resultPolynom.PolyItems.OrderByDescending(x => x.Exponent).ToList();
return resultPolynom;
}
private Polynom CalculateGeneratorPolynom(int numEccWords)
{
var generatorPolynom = new Polynom();
generatorPolynom.PolyItems.AddRange(new[]{
new PolynomItem(0,1),
new PolynomItem(0,0)
});
for (var i = 1; i <= numEccWords - 1; i++)
{
var multiplierPolynom = new Polynom();
multiplierPolynom.PolyItems.AddRange(new[]{
new PolynomItem(0,1),
new PolynomItem(i,0)
});
generatorPolynom = this.MultiplyAlphaPolynoms(generatorPolynom, multiplierPolynom);
}
return generatorPolynom;
}
private Polynom CalculateMessagePolynom(string bitString)
{
var messagePol = new Polynom();
for (var i = bitString.Length / 8 - 1; i >= 0; i--)
{
messagePol.PolyItems.Add(new PolynomItem(this.BinToDec(bitString.Substring(0, 8)), i));
bitString = bitString.Remove(0, 8);
}
return messagePol;
}
private Polynom XORPolynoms(Polynom messagePolynom, Polynom resPolynom)
{
var resultPolynom = new Polynom();
Polynom longPoly, shortPoly;
if (messagePolynom.PolyItems.Count >= resPolynom.PolyItems.Count)
{
longPoly = messagePolynom;
shortPoly = resPolynom;
}
else
{
longPoly = resPolynom;
shortPoly = messagePolynom;
}
for (var i = 0; i < longPoly.PolyItems.Count; i++)
{
var polItemRes = new PolynomItem
(
longPoly.PolyItems[i].Coefficient ^
(shortPoly.PolyItems.Count > i ? shortPoly.PolyItems[i].Coefficient : 0),
messagePolynom.PolyItems[0].Exponent - i
);
resultPolynom.PolyItems.Add(polItemRes);
}
resultPolynom.PolyItems.RemoveAt(0);
return resultPolynom;
}
private Polynom MultiplyGeneratorPolynomByLeadterm(Polynom genPolynom, PolynomItem leadTerm, int lowerExponentBy)
{
var resultPolynom = new Polynom();
foreach (var polItemBase in genPolynom.PolyItems)
{
var polItemRes = new PolynomItem(
(polItemBase.Coefficient + leadTerm.Coefficient) % 255,
polItemBase.Exponent - lowerExponentBy
);
resultPolynom.PolyItems.Add(polItemRes);
}
return resultPolynom;
}
private Polynom MultiplyAlphaPolynoms(Polynom polynomBase, Polynom polynomMultiplier)
{
var resultPolynom = new Polynom();
foreach (var polItemBase in polynomMultiplier.PolyItems)
{
foreach (var polItemMulti in polynomBase.PolyItems)
{
var polItemRes = new PolynomItem
(
ShrinkAlphaExp(polItemBase.Coefficient + polItemMulti.Coefficient),
(polItemBase.Exponent + polItemMulti.Exponent)
);
resultPolynom.PolyItems.Add(polItemRes);
}
}
var exponentsToGlue = resultPolynom.PolyItems.GroupBy(x => x.Exponent).Where(x => x.Count() > 1).Select(x => x.First().Exponent);
var gluedPolynoms = new List<PolynomItem>();
var toGlue = exponentsToGlue as IList<int> ?? exponentsToGlue.ToList();
foreach (var exponent in toGlue)
{
var coefficient = resultPolynom.PolyItems.Where(x => x.Exponent == exponent).Aggregate(0, (current, polynomOld)
=> current ^ this.GetIntValFromAlphaExp(polynomOld.Coefficient));
var polynomFixed = new PolynomItem(this.GetAlphaExpFromIntVal(coefficient), exponent);
gluedPolynoms.Add(polynomFixed);
}
resultPolynom.PolyItems.RemoveAll(x => toGlue.Contains(x.Exponent));
resultPolynom.PolyItems.AddRange(gluedPolynoms);
resultPolynom.PolyItems = resultPolynom.PolyItems.OrderByDescending(x => x.Exponent).ToList();
return resultPolynom;
}
private Polynom CalculateGeneratorPolynom(int numEccWords)
{
var generatorPolynom = new Polynom();
generatorPolynom.PolyItems.AddRange(new []{
new PolynomItem { Coefficient = 0, Exponent = 1},
new PolynomItem { Coefficient = 0, Exponent = 0}
});
for (var i = 1; i <= numEccWords - 1; i++)
{
var multiplierPolynom = new Polynom();
multiplierPolynom.PolyItems.AddRange(new []{
new PolynomItem { Coefficient = 0, Exponent = 1},
new PolynomItem { Coefficient = i, Exponent = 0}
});
generatorPolynom = MultiplyAlphaPolynoms(generatorPolynom, multiplierPolynom);
}
return generatorPolynom;
}
private Polynom ConvertToAlphaNotation(Polynom poly)
{
var newPoly = new Polynom();
for (var i = 0; i < poly.PolyItems.Count; i++)
newPoly.PolyItems.Add(
new PolynomItem(
(poly.PolyItems[i].Coefficient != 0
? this.GetAlphaExpFromIntVal(poly.PolyItems[i].Coefficient)
: 0), poly.PolyItems[i].Exponent));
return newPoly;
}