public void GetSum()
{
var a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
var b = new ComplexFloatVector(new float[4] {
4, 5, 6, 7
});
Assert.AreEqual(a.GetSum(), (ComplexFloat)6);
Assert.AreEqual(6, a.GetSumMagnitudes());
Assert.AreEqual(b.GetSum(), (ComplexFloat)22);
Assert.AreEqual(22, b.GetSumMagnitudes());
}
public void Multiply()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector b = new ComplexFloatVector(new float[4] {
4, 5, 6, 7
});
ComplexDoubleMatrix c = new ComplexDoubleMatrix(a.Length, b.Length);
ComplexDoubleMatrix d = new ComplexDoubleMatrix(a.Length, b.Length);
c = a * b;
d = ComplexFloatVector.Multiply(a, b);
Assert.AreEqual(c[0, 0], a[0] * b[0]);
Assert.AreEqual(c[0, 1], a[0] * b[1]);
Assert.AreEqual(c[0, 2], a[0] * b[2]);
Assert.AreEqual(c[0, 3], a[0] * b[3]);
Assert.AreEqual(c[1, 0], a[1] * b[0]);
Assert.AreEqual(c[1, 1], a[1] * b[1]);
Assert.AreEqual(c[1, 2], a[1] * b[2]);
Assert.AreEqual(c[1, 3], a[1] * b[3]);
Assert.AreEqual(c[2, 0], a[2] * b[0]);
Assert.AreEqual(c[2, 1], a[2] * b[1]);
Assert.AreEqual(c[2, 2], a[2] * b[2]);
Assert.AreEqual(c[2, 3], a[2] * b[3]);
Assert.AreEqual(c[3, 0], a[3] * b[0]);
Assert.AreEqual(c[3, 1], a[3] * b[1]);
Assert.AreEqual(c[3, 2], a[3] * b[2]);
Assert.AreEqual(c[3, 3], a[3] * b[3]);
Assert.AreEqual(d[0, 0], a[0] * b[0]);
Assert.AreEqual(d[0, 1], a[0] * b[1]);
Assert.AreEqual(d[0, 2], a[0] * b[2]);
Assert.AreEqual(d[0, 3], a[0] * b[3]);
Assert.AreEqual(d[1, 0], a[1] * b[0]);
Assert.AreEqual(d[1, 1], a[1] * b[1]);
Assert.AreEqual(d[1, 2], a[1] * b[2]);
Assert.AreEqual(d[1, 3], a[1] * b[3]);
Assert.AreEqual(d[2, 0], a[2] * b[0]);
Assert.AreEqual(d[2, 1], a[2] * b[1]);
Assert.AreEqual(d[2, 2], a[2] * b[2]);
Assert.AreEqual(d[2, 3], a[2] * b[3]);
Assert.AreEqual(d[3, 0], a[3] * b[0]);
Assert.AreEqual(d[3, 1], a[3] * b[1]);
Assert.AreEqual(d[3, 2], a[3] * b[2]);
Assert.AreEqual(d[3, 3], a[3] * b[3]);
}
public void SolveVector()
{
ComplexFloatVector b = new ComplexFloatVector(3);
b[0] = 2;
b[1] = 13;
b[2] = 25;
ComplexFloatVector x = lu.Solve(b);
Assert.AreEqual(x[0].Real, 2.856, TOLERENCE);
Assert.AreEqual(x[1].Real, -0.517, 0.01);
Assert.AreEqual(x[2].Real, 1.333, TOLERENCE);
Assert.AreEqual(x[0].Imag, 0.559, TOLERENCE);
Assert.AreEqual(x[1].Imag, 0.189, TOLERENCE);
Assert.AreEqual(x[2].Imag, -0.541, TOLERENCE);
}
public void ICollection()
{
var a = new ComplexFloatVector(new ComplexFloat[4] {
0, 1, 2, 3
});
var b = new ComplexFloat[5];
Assert.AreEqual(a.Count, a.Length);
a.CopyTo(b, 1);
Assert.AreEqual(b[0], (ComplexFloat)0);
Assert.AreEqual(b[1], (ComplexFloat)0);
Assert.AreEqual(b[2], (ComplexFloat)1);
Assert.AreEqual(b[3], (ComplexFloat)2);
Assert.AreEqual(b[4], (ComplexFloat)3);
}
public void Axpy()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
float scal = 3;
ComplexFloatVector b = new ComplexFloatVector(4);
b.Axpy(scal, a);
a.Scale(scal);
Assert.AreEqual(a[0], b[0]);
Assert.AreEqual(a[1], b[1]);
Assert.AreEqual(a[2], b[2]);
Assert.AreEqual(a[3], b[3]);
}
public void SolveVector()
{
ComplexFloatVector b = new ComplexFloatVector(3);
b[0] = 2;
b[1] = 13;
b[2] = 25;
ComplexFloatVector x = cd.Solve(b);
Assert.AreEqual(x[0].Real, -4.500, TOLERENCE);
Assert.AreEqual(x[1].Real, 12.000, TOLERENCE);
Assert.AreEqual(x[2].Real, 8.333, TOLERENCE);
Assert.AreEqual(x[0].Imag, -6.500, TOLERENCE);
Assert.AreEqual(x[1].Imag, 1.000, TOLERENCE);
Assert.AreEqual(x[2].Imag, 0.000, TOLERENCE);
}
public void GetNorm()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector b = new ComplexFloatVector(new float[4] {
4, 5, 6, 7
});
Assert.AreEqual(a.GetNorm(), System.Math.Sqrt(14), TOLERENCE);
Assert.AreEqual(a.GetNorm(), a.GetNorm(2));
Assert.AreEqual(a.GetNorm(0), 3);
Assert.AreEqual(b.GetNorm(), 3 * System.Math.Sqrt(14), TOLERENCE);
Assert.AreEqual(b.GetNorm(), b.GetNorm(2));
Assert.AreEqual(b.GetNorm(0), 7);
}
public void RealImag()
{
ComplexFloatVector a = new ComplexFloatVector(2);
a[0] = new ComplexFloat(1, 2);
a[1] = new ComplexFloat(3, 4);
FloatVector a_real = a.Real;
FloatVector a_imag = a.Imag;
Assert.AreEqual(a_real[0], a[0].Real);
Assert.AreEqual(a_imag[0], a[0].Imag);
Assert.AreEqual(a_real[1], a[1].Real);
Assert.AreEqual(a_imag[1], a[1].Imag);
Assert.AreEqual(a_real.Length, a.Length);
Assert.AreEqual(a_imag.Length, a.Length);
}
public void Current()
{
var test = new ComplexFloatVector(new ComplexFloat[2] {
1f, 2f
});
IEnumerator enumerator = test.GetEnumerator();
bool movenextresult;
movenextresult = enumerator.MoveNext();
Assert.IsTrue(movenextresult);
Assert.AreEqual(enumerator.Current, test[0]);
movenextresult = enumerator.MoveNext();
Assert.IsTrue(movenextresult);
Assert.AreEqual(enumerator.Current, test[1]);
movenextresult = enumerator.MoveNext();
Assert.IsFalse(movenextresult);
}
public void Clone()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector b = a.Clone();
Assert.AreEqual(a[0], b[0]);
Assert.AreEqual(a[1], b[1]);
Assert.AreEqual(a[2], b[2]);
Assert.AreEqual(a[3], b[3]);
a = a * 2;
Assert.AreEqual(a[0], b[0] * 2);
Assert.AreEqual(a[1], b[1] * 2);
Assert.AreEqual(a[2], b[2] * 2);
Assert.AreEqual(a[3], b[3] * 2);
}
public void Negate()
{
float[] vec = new float[4] {
0, 1, 2, 3
};
ComplexFloatVector a = new ComplexFloatVector(vec);
ComplexFloatVector b = -a;
a = ComplexFloatVector.Negate(a);
Assert.AreEqual(-(ComplexFloat)vec[0], a[0]);
Assert.AreEqual(-(ComplexFloat)vec[1], a[1]);
Assert.AreEqual(-(ComplexFloat)vec[2], a[2]);
Assert.AreEqual(-(ComplexFloat)vec[3], a[3]);
Assert.AreEqual(-(ComplexFloat)vec[0], b[0]);
Assert.AreEqual(-(ComplexFloat)vec[1], b[1]);
Assert.AreEqual(-(ComplexFloat)vec[2], b[2]);
Assert.AreEqual(-(ComplexFloat)vec[3], b[3]);
}
public void IList()
{
ComplexFloatVector a = new ComplexFloatVector(new ComplexFloat[4] {
0, 1, 2, 3
});
Assert.AreEqual(a.IsFixedSize, false);
Assert.AreEqual(a.IsReadOnly, false);
a.Add((ComplexFloat)4.0);
Assert.AreEqual(a.Length, 5);
Assert.AreEqual(a[4], (ComplexFloat)4);
Assert.AreEqual(a.Contains((ComplexFloat)4.0), true);
a.Insert(1, (ComplexFloat)5.0);
Assert.AreEqual(a.Length, 6);
Assert.AreEqual(a.Contains((ComplexFloat)5.0), true);
Assert.AreEqual(a[0], (ComplexFloat)0);
Assert.AreEqual(a[1], (ComplexFloat)5);
Assert.AreEqual(a[2], (ComplexFloat)1);
Assert.AreEqual(a[3], (ComplexFloat)2);
Assert.AreEqual(a[4], (ComplexFloat)3);
Assert.AreEqual(a[5], (ComplexFloat)4);
a.Remove((ComplexFloat)5.0);
Assert.AreEqual(a.Length, 5);
Assert.AreEqual(a.Contains((ComplexFloat)5.0), false);
Assert.AreEqual(a[0], (ComplexFloat)0);
Assert.AreEqual(a[1], (ComplexFloat)1);
Assert.AreEqual(a[2], (ComplexFloat)2);
Assert.AreEqual(a[3], (ComplexFloat)3);
Assert.AreEqual(a[4], (ComplexFloat)4);
a.RemoveAt(2);
Assert.AreEqual(a.Length, 4);
Assert.AreEqual(a.Contains((ComplexFloat)2.0), false);
Assert.AreEqual(a[0], (ComplexFloat)0);
Assert.AreEqual(a[1], (ComplexFloat)1);
Assert.AreEqual(a[2], (ComplexFloat)3);
Assert.AreEqual(a[3], (ComplexFloat)4);
}
public void CopySwap()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector b = new ComplexFloatVector(new float[4] {
4, 5, 6, 7
});
ComplexFloatVector c = new ComplexFloatVector(4);
ComplexFloatVector d = new ComplexFloatVector(4);
a.Copy(c);
b.Copy(d);
Assert.AreEqual(a.Length, c.Length);
Assert.AreEqual(a[0], c[0]);
Assert.AreEqual(a[1], c[1]);
Assert.AreEqual(a[2], c[2]);
Assert.AreEqual(a[3], c[3]);
Assert.AreEqual(b.Length, d.Length);
Assert.AreEqual(b[0], d[0]);
Assert.AreEqual(b[1], d[1]);
Assert.AreEqual(b[2], d[2]);
Assert.AreEqual(b[3], d[3]);
a.Swap(b);
Assert.AreEqual(b.Length, c.Length);
Assert.AreEqual(b[0], c[0]);
Assert.AreEqual(b[1], c[1]);
Assert.AreEqual(b[2], c[2]);
Assert.AreEqual(b[3], c[3]);
Assert.AreEqual(a.Length, d.Length);
Assert.AreEqual(a[0], d[0]);
Assert.AreEqual(a[1], d[1]);
Assert.AreEqual(a[2], d[2]);
Assert.AreEqual(a[3], d[3]);
}
public void Divide()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector c = new ComplexFloatVector(a);
ComplexFloatVector d = new ComplexFloatVector(a);
float scal = -4;
c = a / scal;
d = ComplexFloatVector.Divide(a, scal);
Assert.AreEqual(c[0], a[0] / scal);
Assert.AreEqual(c[1], a[1] / scal);
Assert.AreEqual(c[2], a[2] / scal);
Assert.AreEqual(c[3], a[3] / scal);
Assert.AreEqual(d[0], a[0] / scal);
Assert.AreEqual(d[1], a[1] / scal);
Assert.AreEqual(d[2], a[2] / scal);
Assert.AreEqual(d[3], a[3] / scal);
}
public void Equals()
{
ComplexFloatVector a = new ComplexFloatVector(2, 4);
ComplexFloatVector b = new ComplexFloatVector(2, 4);
ComplexFloatVector c = new ComplexFloatVector(2);
c[0] = (ComplexFloat)4;
c[1] = (ComplexFloat)4;
ComplexFloatVector d = new ComplexFloatVector(2, 5);
ComplexFloatVector e = null;
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(b.Equals(a));
Assert.IsTrue(a.Equals(c));
Assert.IsTrue(b.Equals(c));
Assert.IsTrue(c.Equals(b));
Assert.IsTrue(c.Equals(a));
Assert.IsFalse(a.Equals(d));
Assert.IsFalse(d.Equals(b));
Assert.IsFalse(a.Equals(e));
}
public void Equals()
{
var a = new ComplexFloatVector(2, 4);
var b = new ComplexFloatVector(2, 4);
var c = new ComplexFloatVector(2)
{
[0] = 4,
[1] = 4
};
var d = new ComplexFloatVector(2, 5);
ComplexFloatVector e = null;
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(b.Equals(a));
Assert.IsTrue(a.Equals(c));
Assert.IsTrue(b.Equals(c));
Assert.IsTrue(c.Equals(b));
Assert.IsTrue(c.Equals(a));
Assert.IsFalse(a.Equals(d));
Assert.IsFalse(d.Equals(b));
Assert.IsFalse(a.Equals(e));
}
public void ScalarMultiplyAndDivide()
{
ComplexFloatVector a = new ComplexFloatVector(new float[4] {
0, 1, 2, 3
});
ComplexFloatVector c = new ComplexFloatVector(a);
ComplexFloatVector d = new ComplexFloatVector(a);
float scal = -4;
c.Multiply(scal);
d.Divide(scal);
Assert.AreEqual(c[0], a[0] * scal);
Assert.AreEqual(c[1], a[1] * scal);
Assert.AreEqual(c[2], a[2] * scal);
Assert.AreEqual(c[3], a[3] * scal);
Assert.AreEqual(d[0], a[0] / scal);
Assert.AreEqual(d[1], a[1] / scal);
Assert.AreEqual(d[2], a[2] / scal);
Assert.AreEqual(d[3], a[3] / scal);
c = a * scal;
Assert.AreEqual(c[0], a[0] * scal);
Assert.AreEqual(c[1], a[1] * scal);
Assert.AreEqual(c[2], a[2] * scal);
Assert.AreEqual(c[3], a[3] * scal);
c = scal * a;
Assert.AreEqual(c[0], a[0] * scal);
Assert.AreEqual(c[1], a[1] * scal);
Assert.AreEqual(c[2], a[2] * scal);
Assert.AreEqual(c[3], a[3] * scal);
}
public void CtorCopyNull()
{
ComplexFloatVector a = null;
ComplexFloatVector b = new ComplexFloatVector(a);
}
public void CtorDimensionsNegative()
{
ComplexFloatVector test = new ComplexFloatVector(-1);
}
public void CtorDimensionsZero()
{
ComplexFloatVector test = new ComplexFloatVector(0);
}
public void IndexAccessSetNegative()
{
ComplexFloatVector a = new ComplexFloatVector(2);
a[-1] = (ComplexFloat)1;
}
public void IndexAccessSetOutOfRange()
{
ComplexFloatVector a = new ComplexFloatVector(2);
a[2] = (ComplexFloat)1;
}
