public void Equals()
{
var a = new ComplexDoubleVector(2, 4);
var b = new ComplexDoubleVector(2, 4);
var c = new ComplexDoubleVector(2)
{
[0] = 4,
[1] = 4
};
var d = new ComplexDoubleVector(2, 5);
ComplexDoubleVector e = null;
var f = new FloatVector(2, 4);
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));
Assert.IsFalse(a.Equals(f));
}
private void calculateNextNewFigurePart(ref Figure newFigure, int indWhereWeAreInList, List <Figure> listMoves, List <Point3[]> ptsUsedToCalc, ref List <Point3> toApply)
{
Point3[] ptStartAndEnd = ptsUsedToCalc[indWhereWeAreInList];
Figure moves = listMoves[indWhereWeAreInList];
Point3 ptStart = ptStartAndEnd[0];
Point3 ptEnd = ptStartAndEnd[1];
FloatVector vector = ptEnd.toVector().substract(ptStart.toVector()).normalize();
int i = 0;
FloatVector tempPoint;
Point3 checkPoint;
Figure tempsFigure = new Figure();
do
{
tempPoint = ptStart.toVector().add(vector.multiplyByScalar(i));
checkPoint = tempPoint.toPoint3();
if (i == 0 || !moves[i].toVector().isEquals(tempPoint.vectorWhithAllCoordinatesEquals(0)))
{
foreach (Point3 point in toApply)
{
tempPoint = tempPoint.add(point.toVector());
}
tempsFigure.Add(tempPoint.toPoint3());
}
i++;
}while (checkPoint.toVector().isEquals(ptEnd.toVector()));
tempsFigure.Reverse();
foreach (Point3 point in tempsFigure)
{
newFigure.Add(point);
}
toApply.Add(moves[0]);
}
public ManyToOneDataTableAdaptor(ILinearAlgebraProvider lap, IDataTable dataTable)
: base(lap, dataTable)
{
if (_dataColumnIndex.Count() > 1)
{
throw new NotImplementedException("Sequential datasets not supported with more than one input data column");
}
_rowDepth = new int[dataTable.RowCount];
FloatMatrix inputMatrix = null;
FloatVector outputVector = null;
dataTable.ForEach((row, i) => {
inputMatrix = row.GetField <FloatMatrix>(_dataColumnIndex[0]);
outputVector = row.GetField <FloatVector>(_dataTargetIndex);
_rowDepth[i] = inputMatrix.RowCount;
if (inputMatrix.ColumnCount != outputVector.Size)
{
throw new ArgumentException("Rows between input and output data tables do not match");
}
});
_inputSize = inputMatrix.ColumnCount;
_outputSize = outputVector.Size;
}
public override void ReadFrom(GraphFactory factory, BinaryReader reader)
{
var isElman = reader.ReadBoolean();
var inputSize = reader.ReadInt32();
var memoryId = reader.ReadString();
var memory = FloatVector.ReadFrom(reader);
var activation = _Hydrate(factory, reader);
var activation2 = _Hydrate(factory, reader);
if (_memory == null)
{
_Create(factory, isElman, inputSize, memory.Data, activation, activation2, memoryId);
}
else
{
_memory.Data = memory;
}
var Wh = _input.FindByName("Wh") as INode;
var Wy = _input.FindByName("Wy") as INode;
var Uh = _memory.FindByName("Uh") as INode;
Wh.ReadFrom(factory, reader);
Wy.ReadFrom(factory, reader);
Uh.ReadFrom(factory, reader);
}
public void CtorDimensionsNegative()
{
Assert.Throws(typeof(ArgumentException), () =>
{
var test = new FloatVector(-1);
});
}
public void IndexAccessGetOutOfRange()
{
FloatVector a = new FloatVector(new float[2] {
0, 1
});
float b = a[2];
}
public void GetIndex()
{
FloatVector a = new FloatVector(new float[4] {
1, 2, 3, 4
});
FloatVector b = new FloatVector(new float[4] {
3, 2, 1, 0
});
FloatVector c = new FloatVector(new float[4] {
0, -1, -2, -3
});
FloatVector d = new FloatVector(new float[4] {
-3, -2, -1, 0
});
Assert.AreEqual(a.GetAbsMaximumIndex(), 3);
Assert.AreEqual(b.GetAbsMaximumIndex(), 0);
Assert.AreEqual(c.GetAbsMaximumIndex(), 3);
Assert.AreEqual(d.GetAbsMaximumIndex(), 0);
Assert.AreEqual(a.GetAbsMaximum(), 4);
Assert.AreEqual(b.GetAbsMaximum(), 3);
Assert.AreEqual(c.GetAbsMaximum(), -3);
Assert.AreEqual(d.GetAbsMaximum(), -3);
Assert.AreEqual(a.GetAbsMinimumIndex(), 0);
Assert.AreEqual(b.GetAbsMinimumIndex(), 3);
Assert.AreEqual(c.GetAbsMinimumIndex(), 0);
Assert.AreEqual(d.GetAbsMinimumIndex(), 3);
Assert.AreEqual(a.GetAbsMinimum(), 1);
Assert.AreEqual(b.GetAbsMinimum(), 0);
Assert.AreEqual(c.GetAbsMinimum(), 0);
Assert.AreEqual(d.GetAbsMinimum(), 0);
}
public FloatVector(FloatVector other) : this(csharpaidiclientPINVOKE.new_FloatVector__SWIG_1(FloatVector.getCPtr(other)), true)
{
if (csharpaidiclientPINVOKE.SWIGPendingException.Pending)
{
throw csharpaidiclientPINVOKE.SWIGPendingException.Retrieve();
}
}
public void TestAdd()
{
FloatVector vect1 = new FloatVector(new float[] { 1, 2, 3 });
FloatVector vect2 = new FloatVector(new float[] { 3, 2, 1 });
Assert.IsTrue(vect1.vectorWhithAllCoordinatesEquals(4).isEquals(vect1.add(vect2)));
}
private unsafe void DoFindPath(Vector3 start, Vector3 end, float agentSize,
ref List <PathPoint> oPath)
{
SVONPathPoint *pathPoints = null;
int pointsCount = 0;
FloatVector startPos = new FloatVector(start);
FloatVector targetPos = new FloatVector(end);
using (GenerateFindPathWrapper(volumeHandle, startPos, targetPos, agentSize,
out pathPoints, out pointsCount))
{
SVONPathPoint *pPoint = pathPoints;
for (int i = 0; i < pointsCount; ++i)
{
PathPoint ppt = new PathPoint
{
layer = pPoint->layer,
mortonCode = pPoint->mortonCode,
position = pPoint->position.ToVector3()
};
oPath.Add(ppt);
++pPoint;
}
}
}
private static unsafe extern bool SVONFindPath(IntPtr volume,
FloatVector startPos,
FloatVector targetPos,
float agentSize,
out PathSafeHandle pathHandle,
out SVONPathPoint *pathPoints,
out int count);
public override void ReadFrom(GraphFactory factory, BinaryReader reader)
{
var lap = factory?.LinearAlgebraProvider;
InputSize = reader.ReadInt32();
OutputSize = reader.ReadInt32();
// read the bias parameters
var bias = FloatVector.ReadFrom(reader);
if (Bias == null)
{
Bias = lap.CreateVector(bias);
}
else
{
Bias.Data = bias;
}
// read the weight parameters
var weight = FloatMatrix.ReadFrom(reader);
if (Weight == null)
{
Weight = lap.CreateMatrix(weight);
}
else
{
Weight.Data = weight;
}
if (_updater == null)
{
_updater = factory?.CreateWeightUpdater(Weight);
}
}
/// <summary>
/// Creates random integers added together as feature vectors
/// The input feature contains two features, one for each bit at that position
/// The output feature contains a single feature: 1 or 0 if that bit is set in the result
/// </summary>
/// <param name="sampleCount">How many samples to generate</param>
/// <param name="stochastic">True to generate random integers</param>
/// <returns>A list of sequences</returns>
public static IDataTable Addition(int sampleCount, bool stochastic)
{
Random rand = stochastic ? new Random() : new Random(0);
var builder = DataTableBuilder.CreateTwoColumnMatrix();
for (var i = 0; i < sampleCount; i++)
{
// generate some random numbers (sized to prevent overflow)
var a = rand.Next(int.MaxValue / 2);
var b = rand.Next(int.MaxValue / 2);
var a2 = _GetBitArray(a);
var b2 = _GetBitArray(b);
var r2 = _GetBitArray(a + b);
var inputList = new FloatVector[r2.Length];
var outputList = new FloatVector[r2.Length];
for (int j = 0; j < r2.Length; j++)
{
inputList[j] = new FloatVector {
Data = new[] { a2[j], b2[j] }
};
outputList[j] = new FloatVector {
Data = new[] { r2[j] }
};
}
builder.Add(FloatMatrix.Create(inputList), FloatMatrix.Create(outputList));
}
return(builder.Build());
}
static void Main(string[] args)
{
MyCallback myCallbackObj = new MyCallback();
CppClass instance = MyDLL.CreateInstance();
string str = "テストHello World!";
instance.SetString(str);
Debug.WriteLine($"str = {instance.GetString()}");
FloatVector v = new FloatVector();
v.Add((float)-0.1);
v.Add((float)-1);
v.Add((float)-10);
int i = 0;
instance.SetVector(v);
FloatVector buf = instance.GetVector();
foreach (float value in buf)
{
Debug.WriteLine($"[{i}] :value = {value}");
i += 1;
}
instance.SetCallback(myCallbackObj);
instance.ExeCallback();
}
/// <summary>
/// One hot encodes the REBER strings
/// </summary>
/// <param name="strList">A list of REBER sequences</param>
/// <returns>A data table with matrices to represent the sequences of vectors and their corresponding outputs</returns>
public static IDataTable GetOneHot(IEnumerable <string> strList)
{
var strList2 = strList.ToList();
// build the following item table
var following = new Dictionary <string, HashSet <int> >();
foreach (var str in strList2)
{
var sb = new StringBuilder();
string prev = null;
foreach (var ch in str)
{
sb.Append(ch);
var key = sb.ToString();
if (prev != null)
{
if (!following.TryGetValue(prev, out HashSet <int> temp))
{
following.Add(prev, temp = new HashSet <int>());
}
temp.Add(_ch[ch]);
}
prev = key;
}
}
var builder = DataTableBuilder.CreateTwoColumnMatrix();
foreach (var str in strList2)
{
var inputList = new FloatVector[str.Length];
var outputList = new FloatVector[str.Length];
var sb = new StringBuilder();
for (var i = 0; i < str.Length; i++)
{
var ch = str[i];
sb.Append(ch);
var input = new float[_ch.Count];
var output = new float[_ch.Count];
input[_ch[ch]] = 1f;
if (following.TryGetValue(sb.ToString(), out HashSet <int> temp))
{
foreach (var item in temp)
{
output[item] = 1f;
}
}
inputList[i] = new FloatVector {
Data = input
};
outputList[i] = new FloatVector {
Data = output
};
}
builder.Add(FloatMatrix.Create(inputList), FloatMatrix.Create(outputList));
}
return(builder.Build());
}
public override void ReadFrom(GraphFactory factory, BinaryReader reader)
{
var inputSize = reader.ReadInt32();
var memoryId = reader.ReadString();
var memory = FloatVector.ReadFrom(reader);
if (_memory == null)
{
_Create(factory, inputSize, memory.Data, memoryId);
}
else
{
_memory.Data = memory;
}
var Wf = _input.FindByName("Wf") as FeedForward;
var Wi = _input.FindByName("Wi") as FeedForward;
var Wo = _input.FindByName("Wo") as FeedForward;
var Wc = _input.FindByName("Wc") as FeedForward;
var Uf = _memory.FindByName("Uf") as FeedForward;
var Ui = _memory.FindByName("Ui") as FeedForward;
var Uo = _memory.FindByName("Uo") as FeedForward;
var Uc = _memory.FindByName("Uc") as FeedForward;
Wf.ReadFrom(factory, reader);
Wi.ReadFrom(factory, reader);
Wo.ReadFrom(factory, reader);
Wc.ReadFrom(factory, reader);
Uf.ReadFrom(factory, reader);
Ui.ReadFrom(factory, reader);
Uo.ReadFrom(factory, reader);
Uc.ReadFrom(factory, reader);
}
public void IndexAccessGetNegative()
{
FloatVector a = new FloatVector(new float[2] {
0, 1
});
float b = a[-1];
}
public override void ReadFrom(GraphFactory factory, BinaryReader reader)
{
var inputSize = reader.ReadInt32();
var memoryId = reader.ReadString();
var memory = FloatVector.ReadFrom(reader);
if (_memory == null)
{
_Create(factory, inputSize, memory.Data, memoryId);
}
else
{
_memory.Data = memory;
}
var Wh = _input.FindByName("Wh") as INode;
var Wr = _input.FindByName("Wr") as INode;
var Wz = _input.FindByName("Wz") as INode;
var Uh = _memory.FindByName("Uh") as INode;
var Ur = _memory.FindByName("Ur") as INode;
var Uz = _memory.FindByName("Uz") as INode;
Wh.ReadFrom(factory, reader);
Wr.ReadFrom(factory, reader);
Wz.ReadFrom(factory, reader);
Uh.ReadFrom(factory, reader);
Ur.ReadFrom(factory, reader);
Uz.ReadFrom(factory, reader);
}
public void ImplicitConversion()
{
float[] a = new float[4] {
0, 1, 2, 3
};
float[] b = new float[4] {
0, 1, 2, 3
};
FloatVector c = new FloatVector(a);
FloatVector d, e, f;
d = a; e = b; f = c;
Assert.AreEqual(a.Length, d.Length);
Assert.AreEqual((float)a[0], d[0]);
Assert.AreEqual((float)a[1], d[1]);
Assert.AreEqual((float)a[2], d[2]);
Assert.AreEqual((float)a[3], d[3]);
Assert.AreEqual(b.Length, e.Length);
Assert.AreEqual((float)b[0], e[0]);
Assert.AreEqual((float)b[1], e[1]);
Assert.AreEqual((float)b[2], e[2]);
Assert.AreEqual((float)b[3], e[3]);
Assert.AreEqual(c.Length, f.Length);
Assert.AreEqual((float)c[0], f[0]);
Assert.AreEqual((float)c[1], f[1]);
Assert.AreEqual((float)c[2], f[2]);
Assert.AreEqual((float)c[3], f[3]);
}
public override void ReadFrom(GraphFactory factory, BinaryReader reader)
{
var inputSize = reader.ReadInt32();
var memoryId = reader.ReadString();
var memory = FloatVector.ReadFrom(reader);
if (_memory == null)
{
_Create(factory, inputSize, memory.Data, memoryId);
}
else
{
_memory.Data = memory;
}
var Wx = _input.FindByName("Wx");
var Wi = _input.FindByName("Wi");
var Wf = _input.FindByName("Wf");
var Ui = _memory.FindByName("Ui");
var Uf = _memory.FindByName("Uf");
Wx.ReadFrom(factory, reader);
Wi.ReadFrom(factory, reader);
Wf.ReadFrom(factory, reader);
Ui.ReadFrom(factory, reader);
Uf.ReadFrom(factory, reader);
}
public void ImplicitConversion()
{
float[] a = new float[4] {
0, 1, 2, 3
};
double[] b = new double[4] {
0, 1, 2, 3
};
var c = new FloatVector(a);
DoubleVector d, e, f;
d = (DoubleVector)a;
e = (DoubleVector)b;
f = (DoubleVector)c;
Assert.AreEqual(a.Length, d.Length);
Assert.AreEqual((double)a[0], d[0]);
Assert.AreEqual((double)a[1], d[1]);
Assert.AreEqual((double)a[2], d[2]);
Assert.AreEqual((double)a[3], d[3]);
Assert.AreEqual(b.Length, e.Length);
Assert.AreEqual(b[0], e[0]);
Assert.AreEqual(b[1], e[1]);
Assert.AreEqual(b[2], e[2]);
Assert.AreEqual(b[3], e[3]);
Assert.AreEqual(c.Length, f.Length);
Assert.AreEqual((double)c[0], f[0]);
Assert.AreEqual((double)c[1], f[1]);
Assert.AreEqual((double)c[2], f[2]);
Assert.AreEqual((double)c[3], f[3]);
}
public FloatVector(FloatVector other) : this(MyDLLPINVOKE.new_FloatVector__SWIG_1(FloatVector.getCPtr(other)), true)
{
if (MyDLLPINVOKE.SWIGPendingException.Pending)
{
throw MyDLLPINVOKE.SWIGPendingException.Retrieve();
}
}
public void GetEnumerator()
{
FloatVector a = new FloatVector(new float[4] {
0, 1, 2, 3
});
IEnumerator dve = a.GetEnumerator();
float b;
bool c;
c = dve.MoveNext();
b = (float)dve.Current;
Assert.AreEqual(c, true);
Assert.AreEqual(b, 0);
c = dve.MoveNext();
b = (float)dve.Current;
Assert.AreEqual(c, true);
Assert.AreEqual(b, 1);
c = dve.MoveNext();
b = (float)dve.Current;
Assert.AreEqual(c, true);
Assert.AreEqual(b, 2);
c = dve.MoveNext();
b = (float)dve.Current;
Assert.AreEqual(c, true);
Assert.AreEqual(b, 3);
c = dve.MoveNext();
Assert.AreEqual(c, false);
}
public FloatVectorEnumerator(FloatVector collection)
{
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
public void Add()
{
FloatVector a = new FloatVector(new float[4] {
0, 1, 2, 3
});
FloatVector b = new FloatVector(new float[4] {
4, 5, 6, 7
});
FloatVector c = new FloatVector(a.Length);
FloatVector d = new FloatVector(b.Length);
c = a + b;
d = FloatVector.Add(a, b);
Assert.AreEqual(c[0], a[0] + b[0]);
Assert.AreEqual(c[1], a[1] + b[1]);
Assert.AreEqual(c[2], a[2] + b[2]);
Assert.AreEqual(c[3], a[3] + b[3]);
Assert.AreEqual(d[0], c[0]);
Assert.AreEqual(d[1], c[1]);
Assert.AreEqual(d[2], c[2]);
Assert.AreEqual(d[3], c[3]);
a.Add(b);
Assert.AreEqual(c[0], a[0]);
Assert.AreEqual(c[1], a[1]);
Assert.AreEqual(c[2], a[2]);
Assert.AreEqual(c[3], a[3]);
}
public void Subtract()
{
FloatVector a = new FloatVector(new float[4] {
0, 1, 2, 3
});
FloatVector b = new FloatVector(new float[4] {
4, 5, 6, 7
});
FloatVector c = new FloatVector(a.Length);
FloatVector d = new FloatVector(b.Length);
c = a - b;
d = FloatVector.Subtract(a, b);
Assert.AreEqual(c[0], a[0] - b[0]);
Assert.AreEqual(c[1], a[1] - b[1]);
Assert.AreEqual(c[2], a[2] - b[2]);
Assert.AreEqual(c[3], a[3] - b[3]);
Assert.AreEqual(d[0], c[0]);
Assert.AreEqual(d[1], c[1]);
Assert.AreEqual(d[2], c[2]);
Assert.AreEqual(d[3], c[3]);
a.Subtract(b);
Assert.AreEqual(c[0], a[0]);
Assert.AreEqual(c[1], a[1]);
Assert.AreEqual(c[2], a[2]);
Assert.AreEqual(c[3], a[3]);
}
public void SetRange(int index, FloatVector values)
{
MyDLLPINVOKE.FloatVector_SetRange(swigCPtr, index, FloatVector.getCPtr(values));
if (MyDLLPINVOKE.SWIGPendingException.Pending)
{
throw MyDLLPINVOKE.SWIGPendingException.Retrieve();
}
}
public static void AssertEqual(FloatVector v1, FloatVector v2, int maxDifference = 6)
{
Assert.AreEqual(v1.Count, v2.Count);
for (var i = 0; i < v1.Count; i++)
{
AssertEqual(v1.Data[i], v2.Data[i], maxDifference);
}
}
public void CtorInitialValues()
{
FloatVector test = new FloatVector(2, 1);
Assert.AreEqual(test.Length, 2);
Assert.AreEqual(test[0], 1);
Assert.AreEqual(test[1], 1);
}
public void CtorDimensions()
{
FloatVector test = new FloatVector(2);
Assert.AreEqual(test.Length, 2);
Assert.AreEqual(test[0], 0);
Assert.AreEqual(test[1], 0);
}
public void Convolve(Sound kernel,int channelTo, int channelFrom)
{
FloatVector kernelVector = new FloatVector(kernel.mSound[channelFrom]);
FloatVector dataVector = new FloatVector(mSound[channelTo]);
Float1DConvolution convolution = new Float1DConvolution(kernelVector,dataVector.Length);
FloatVector result = convolution.Convolve(dataVector);
mSound[channelTo] = result.ToArray();
}
