public Vector(double[] vector, double label, int id)
: base()
{
this.values = vector.ToArray();
this.label = label;
this.Id = id;
}
/// <summary>
/// Create surface data of a sphere
/// </summary>
/// <param name="n">number of facettes per angle</param>
/// <param name="X">[output] X coords</param>
/// <param name="Y">[output] Y coords</param>
/// <param name="Z">[output] Z coords</param>
public static void sphere(int n, out ILArray<double> X,out ILArray<double> Y,out ILArray<double> Z) {
ILArray<double> phi = repmat(linspace(-pi,pi,n).T,1,n);
ILArray<double> rho = repmat(linspace(0,pi,n),n,1);
Y = sin(phi) * sin(rho);
X = cos(phi) * sin(rho);
Z = cos(rho);
}
// The special constructor is used to deserialize values.
public Vector(SerializationInfo info, StreamingContext context)
{
label = (double)info.GetValue("label", typeof(double));
valuesMDF = (ILArray<double>)info.GetValue("valuesMDF", typeof(ILArray<double>));
values = (ILArray<double>)info.GetValue("values", typeof(ILArray<double>));
id = (int)info.GetValue("id", typeof(int));
}
// Wake Code - Matlab
// Rasmus Christensen
// Control and Automation, Aalborg University
// N_turb = number of turbines.
// X_turb = x-position of turbine.
// Y_turb = y-position of turbine.
#endregion
internal static void ROTATE_corrd(out ILArray<double> out_x, out ILArray<double> out_y, ILArray<double> xTurb, ILArray<double> yTurb, double rotA)
{
#region "Used variables declaration"
ILArray<double> x_out;
ILArray<double> y_out;
int i;
#endregion
x_out = zeros(1, length(xTurb)); // Initialization x-coordinates
y_out = zeros(1, length(yTurb)); // Initialization y-coordinates
rotA = rotA * pi / 180; // Conversion to radians
for (i = 1; i <= length(xTurb); i++)
{
x_out._(i, '=', xTurb._(i) * cos(rotA) - xTurb._(i) * sin(rotA));
y_out._(i, '=', xTurb._(i) * sin(rotA) + yTurb._(i) * cos(rotA));
}
if (min_(x_out) < 0) // Moves the x-points if these are negative.
{
x_out = x_out + 500 + abs(min_(x_out));
}
if (min_(y_out) < 0) // Moves the y-points if these are negative.
{
y_out = y_out + 500 + abs(min_(y_out));
}
out_x = x_out;
out_y = y_out;
}
private static void load(string windMatFilePath, out ILArray<double> wind)
{
using (var WindMatFile = new ILMatFile(windMatFilePath))
{
wind = WindMatFile.GetArray<double>("wind");
}
}
// Wake Code - Matlab
// Rasmus Christensen
// Control and Automation, Aalborg University
#endregion
internal static void WT_order(out ILArray<double> xOrder, out ILArray<double> yOrder, ILArray<double> xTurb, ILArray<double> yTurb)
{
#region "Used variables declaration"
ILArray<double> sorted;
ILArray<double> turbineOrder;
int sortCtr;
int i;
int j;
#endregion
sorted = sortrows(__[ xTurb.T, yTurb.T ], 1);
turbineOrder = zeros(length(sorted), 2);
sortCtr = 0;
for (i = 1; i <= length(sorted); i++)
{
for (j = i + 1; j <= length(sorted); j++)
{
if (sorted._(i, 1) == sorted._(j, 1))
{
sortCtr = sortCtr + 1;
}
}
turbineOrder[_(i, ':', i + sortCtr), _(':')] = sortrows(sorted[_(i, ':', i + sortCtr), _(':')], 2);
sortCtr = 0;
}
xOrder = turbineOrder[_(':'), _(1)];
yOrder = turbineOrder[_(':'), _(2)];
}
public ClusterX(SerializationInfo info, StreamingContext context)
: base(info, context)
{
child = (Node)info.GetValue("child", typeof(Node));
covarianceMatrixMDF = (ILArray<double>)info.GetValue("covarianceMatrixMDF", typeof(ILArray<double>));
label = (double)info.GetValue("label", typeof(double));
}
private void TestBucketSortArrayMatrixRow() {
try {
ILArray<string> A = new ILArray<string>(3,4);
A[0,0] = "abc";
A[0,1] = "rtu";
A[0,2] = "sfkw";
A[0,3] = "lsdkfi";
A[1,0] = "iowejkc";
A[1,1] = "cjks";
A[1,2] = "wokys";
A[1,3] = "suem,";
A[2,0] = "fgj";
A[2,1] = "JKSF";
A[2,2] = "SEs";
A[2,3] = "SEFsr";
ILArray<double> ind;
ILArray<string> res = ILMath.sort(A,out ind,0,false);
if (!res.Equals(A[ind]))
throw new Exception("invalid indices/values detected");
ILArray<Int16> indI = ILMath.toint16(ILMath.counter(0.0,1.0,A.Dimensions.ToIntArray()));
res = ILMath.sort(A,ref indI, 0, true, new ILASCIIKeyMapper());
if (!res.Equals(A[indI]))
throw new Exception("invalid indices/values detected");
Success(" elapsed: " + m_stopwatch.ElapsedMilliseconds + " ms");
} catch (Exception e) {
Error(0, e.Message);
}
}
public static ILArray<double> cross(ILArray<double> A, ILArray<double> B, int dim)
{
// Input checking
if (!A.m_dimensions.IsSameShape(B.m_dimensions))
throw new ILDimensionMismatchException("Inputs must have the same size and shape.");
ILDimension outDims = A.m_dimensions;
double[] outArray = ILMemoryPool.Pool.New<double>(outDims.NumberOfElements);
if (dim >= outDims.NumberOfDimensions || dim < 0)
throw new Exception("Specified dim is out of bounds of the array!");
if (outDims[dim] != 3)
throw new Exception("Must have length 3 in the dimension where the cross product is taken.");
// Cross Product
int SID = outDims.SequentialIndexDistance(dim);
int crosses = outDims.NumberOfElements / 3;
int SID2 = 2 * SID;
for (int i = 0; i < crosses; i++)
{
outArray[i] = A.m_data[SID + i] * B.m_data[SID2 + i] - A.m_data[SID2 + i] * B.m_data[SID + i];
outArray[SID + i] = A.m_data[SID2 + i] * B.m_data[i] - A.m_data[i] * B.m_data[SID2 + i];
outArray[SID2 + i] = A.m_data[i] * B.m_data[SID + i] - A.m_data[SID + i] * B.m_data[i];
}
return new ILArray<double>(outArray, outDims);
}
private static void forwBackwGenCheck(IILFFT fft, ILArray<fcomplex> A, ILArray<fcomplex> Result, int dim, float mult) {
ILArray<fcomplex> B = fft.FFTForward1D(A, dim);
if (ILMath.sumall(ILMath.abs(Result - B))/A.Dimensions.NumberOfElements / A.Dimensions[dim] > (double)ILMath.MachineParameterFloat.eps * mult)
throw new Exception("invalid value");
B = fft.FFTBackward1D(B, dim);
if (ILMath.sumall(ILMath.abs(A - B))/A.Dimensions.NumberOfElements / A.Dimensions[dim] > (double)ILMath.MachineParameterFloat.eps * mult)
throw new Exception("invalid value");}
/// <summary>
/// convert sequential index into subscript indices
/// </summary>
/// <param name="A">input array</param>
/// <param name="seqindex">sequential index</param>
/// <returns>subscript indices</returns>
/// <remarks><para>the length of the value returned will be the number of dimensions of A</para>
/// <para>if A is null or empty array, the return value will be of length 0</para>
/// </remarks>
/// <exception cref="System.IndexOutOfRangeException">if seqindex is < 0 or > numel(A)</exception>
public static int[] ind2sub(ILArray<complex> A, int seqindex) {
if (object.Equals(A,null) || A.IsEmpty)
return new int[0];
int [] ret = new int[A.Dimensions.NumberOfDimensions];
A.GetValueSeq(seqindex,ref ret);
return ret;
}
/// <summary>
/// trace of matrix
/// </summary>
/// <param name="A">input matrix, size [m x n]</param>
/// <returns>scalar of same type as A with the sum of diagonal elements of A.</returns>
public static /*!HC:inCls1*/ ILArray<double> trace (/*!HC:inCls1*/ ILArray<double> A) {
if (A.IsEmpty)
return /*!HC:inCls1*/ ILArray<double> .empty(A.Dimensions);
if (A.IsVector || A.IsScalar)
return A[0];
return sum(diag(A));
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>
/// trace of matrix
/// </summary>
/// <param name="A">input matrix, size [m x n]</param>
/// <returns>scalar of same type as A with the sum of diagonal elements of A.</returns>
public static ILArray<complex> trace ( ILArray<complex> A) {
if (A.IsEmpty)
return ILArray<complex> .empty(A.Dimensions);
if (A.IsVector || A.IsScalar)
return A[0];
return sum(diag(A));
}
/// <summary>
/// Sinus of array elements
/// </summary>
/// <param name="A">input array</param>
/// <returns>Sinus of elements from input array</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static /*!HC:outCls*/ ILArray<double> /*!HC:HCfuncname*/ sin (/*!HC:inCls1*/ ILArray<double> A) {
if (A.IsEmpty)
return /*!HC:outCls*/ ILArray<double> .empty(A.Dimensions);
ILDimension inDim = A.Dimensions;
/*!HC:outArr*/ double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new /*!HC:outArr*/ double [newLength];
retDblArr = ILMemoryPool.Pool.New</*!HC:outArr*/ double > (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed (/*!HC:outArr*/ double * pOutArr = retDblArr)
fixed (/*!HC:inArr1*/ double * pInArr = A.m_data) {
/*!HC:outArr*/ double * lastElement = pOutArr + retDblArr.Length;
/*!HC:outArr*/ double * tmpOut = pOutArr;
/*!HC:inArr1*/ double * tmpIn = pInArr;
while (tmpOut < lastElement) { // HC02
/*!HC:HCCompute02*/
*tmpOut++ = /*!HC:HCoperation*/ Math.Sin ( *tmpIn++ ) /*!HC:HCpostOp*/ ;
}
}
}
return new /*!HC:outCls*/ ILArray<double> ( retDblArr, inDim );
}
// The special constructor is used to deserialize values.
public Cluster(SerializationInfo info, StreamingContext context)
{
clusterPair = (ClusterPair)info.GetValue("clusterPair", typeof(ClusterPair));
items = (List<Vector>)info.GetValue("items", typeof(List<Vector>));
mean = (Vector)info.GetValue("mean", typeof(Vector));
meanMDF = (ILArray<double>)info.GetValue("meanMDF", typeof(ILArray<double>));
parent = (Node)info.GetValue("parent", typeof(Node));
}
/// <summary>
/// imaginary part of complex array elements
/// </summary>
/// <param name="X">complex input array</param>
/// <returns>imaginary part of complex array</returns>
public static /*!HC:outCls1*/ ILArray<double> imag (/*!HC:inCls1*/ ILArray<complex> X) {
int nrX = X.m_dimensions.NumberOfElements;
/*!HC:outArr1*/ double [] retArr = new /*!HC:outArr1*/ double [nrX];
/*!HC:outCls1*/ ILArray<double> ret = new /*!HC:outCls1*/ ILArray<double> (retArr,X.m_dimensions);
for (int i= 0; i < nrX; i++) {
retArr[i] = X.GetValue(i).imag;
}
return ret;
}
public void Test_Serialize() {
int errorCode = 0;
try {
double[] data = new double[1000 * 1000 * 10];
String filename = "ILDoubleArray_SerializeTest1.ils";
for (int i = 0; i < data.Length; i++)
data[i] = (double)i;
ILArray<double> A = new ILArray<double>(data, 1000,1000,10);
FileStream fs = new FileStream(filename, FileMode.Create);
Info("Serializing to file: (please wait...)");
A.Serialize(fs);
fs.Close();
FileInfo fi = new FileInfo(filename);
Info("Serialized to file: [1000 x 1000 x 10] => " + ((int)(fi.Length/1024)) + "kB");
// create reference storage from smaler range -> should Detach()
errorCode = 1;
filename = "ILDoubleArray_SerializeTest2.ils";
fs = new FileStream(filename, FileMode.Create);
ILArray<double> AR1 = (ILArray<double>)A[0,"0:600;30:400;0:end"];
AR1.Serialize(fs);
fs.Close();
fi = new FileInfo(filename);
Info("Serialized to file: [600 x 360 x 10] => " + ((int)(fi.Length / 1024)) + "kB");
// if reference storage saved effective memory - keep it as reference
errorCode = 2;
filename = "ILDoubleArray_SerializeTest3.ils";
fs = new FileStream(filename, FileMode.Create);
ILArray<double> AR2 = (ILArray<double>)A[0,"0:end,0:end;0:end,0:end;0:end"];
AR2.Serialize(fs);
fs.Close();
fi = new FileInfo(filename);
Info("Serialized to file: [2000 x 2000 x 20] => " + ((int)(fi.Length / 1024)) + "kB");
// test if small reference would NOT store full data array
errorCode = 4;
filename = "ILDoubleArray_SerializeTest4.ils";
fs = new FileStream(filename, FileMode.Create);
ILArray<double> AR3 = (ILArray<double>)A["3;3;1"];
AR3.Serialize(fs);
fs.Close();
fi = new FileInfo(filename);
Info("Serialized to file: [1 x 1] => " + ((int)(fi.Length / 1024)) + "kB");
if (fi.Length > 1024 * 2)
throw new Exception("Small reference storages should get detached before serializing!");
errorCode = 5;
Success("Test_serialize successfull");
} catch (SerializationException e) {
Error("Test_serialize failed on ErrorCode: "+ errorCode +"due: " + e.Message);
} catch (Exception e) {
Error("Test_serialize failed on ErrorCode: " + errorCode + "due: " + e.Message);
}
}
/// <summary>Unique and sorted elements of a vector.</summary>
/// <param name="X">Elements from which to extract unique values (treated as a vector).</param>
/// <param name="whereResultInX">Indices (same size as retValue) such that x[whereResultInX] = retValue.</param>
/// <param name="whereXInResult">Indices (same size as x) such that retValue[whereXInResult] = x.</param>
/// <returns>Sorted row vector with size less than or equal to x where no 2 elements have the same value.</returns>
public static ILArray<double> unique(ILArray<double> X, out ILArray<double> whereResultInX, out ILArray<double> whereXInResult)
{
// 1. Handle empty and singleton cases
if (X.IsEmpty)
{
whereResultInX = new ILArray<double>();
whereXInResult = new ILArray<double>();
return new ILArray<double>();
}
if (X.IsScalar)
{
whereResultInX = new ILArray<double>(new double[] { 0 });
whereXInResult = new ILArray<double>(new double[] { 0 });
return X.C;
}
// 2. Sort
double[] x = (double[])X.m_data.Clone();
int[] oldXInd = ILMemoryPool.Pool.New<int>(x.Length);
for (int i = 0; i < x.Length; i++)
oldXInd[i] = i;
Array.Sort(x, oldXInd);
// 3. Declarations
int unqCount = 1;
for (int i = 1; i < x.Length; i++)
if (x[i - 1] != x[i])
unqCount++;
double[] unq = ILMemoryPool.Pool.New<double>(unqCount);
double[] wxnr = ILMemoryPool.Pool.New<double>(x.Length);
double[] wrnx = ILMemoryPool.Pool.New<double>(unqCount);
// 4. Unique
unq[0] = x[0];
wxnr[oldXInd[0]] = 0;
wrnx[0] = oldXInd[0];
for (int i = 1, j = 1; i < x.Length; i++)
{
if (x[i - 1] != x[i])
{
unq[j] = x[i];
wrnx[j] = oldXInd[i];
j++;
}
wxnr[oldXInd[i]] = j - 1;
}
whereResultInX = new ILArray<double>(wrnx);
whereXInResult = new ILArray<double>(wxnr);
return new ILArray<double>(unq);
}
/// <summary>
/// multiply and fold array elements along first non singleton dimension
/// </summary>
/// <param name="inArray">N-dimensional double array</param>
/// <returns>array having the first non singleton dimension
/// reduced to the length 1 with the result of the products of
/// corresponding elements of inArray in that dimension.
/// The result will have the same number of dimensions as
/// inArray, but the first non singleton dimension having the
/// size 1.</returns>
public static ILArray<double> prod(ILArray<double> inArray) {
int[] newDims = inArray.Dimensions.ToIntArray();
int nsDim = 0;
while (nsDim < newDims.Length && newDims[nsDim] < 2)
nsDim++;
if (nsDim == newDims.Length)
// scalar -> return copy
return (ILArray<double>)inArray.Clone();
return prod(inArray, nsDim);
}
private static void forwBackwGenCheck(IILFFT fft, ILArray<double> A, ILArray<complex> Result, int dim, double mult) {
ILArray<complex> B = fft.FFTForward1D(A, dim);
if (ILMath.sumall(ILMath.abs(Result - B))/A.Dimensions.NumberOfElements / A.Dimensions[dim] > ILMath.MachineParameterDouble.eps * mult)
throw new Exception("invalid value");
ILArray<double> ResultR = fft.FFTBackwSym1D(B,dim);
if (ILMath.sumall(ILMath.abs(ResultR - A))/A.Dimensions.NumberOfElements / A.Dimensions[dim] > ILMath.MachineParameterDouble.eps * mult)
throw new Exception("invalid value");
B = fft.FFTBackward1D(B, dim);
if (ILMath.sumall(ILMath.abs(ILMath.tocomplex(A) - B))/A.Dimensions.NumberOfElements / A.Dimensions[dim] > ILMath.MachineParameterDouble.eps * mult)
throw new Exception("invalid value");}
//private void wakeCalculation(ILArray<double> Ct, int i, ILCell wind, out ILArray<double> v_nac)
public static void Calculate(ILArray<double> Ct, int i, ILMatFile wind, out ILArray<double> v_nac)
{
//% v_nac = WAKECALCULATION(Ct,i,wind)
//This function calculates the wake
//Currently it is a very very simplified wake calculation. It just serves as
//a placeholder for a correct wake calculation that will come later
ILArray<double> scaling = ILMath.linspace(0.5, 0.9, Ct.Length);
v_nac = scaling * wind.GetArray<double>("wind").GetValue(i - 1, 1);
}
/// <summary>
/// real part of complex array
/// </summary>
/// <param name="X">complex input array</param>
/// <returns>real part of complex array</returns>
public static /*!HC:outCls1*/ ILArray<double> real (/*!HC:inCls1*/ ILArray<complex> X) {
int nrX = X.m_dimensions.NumberOfElements;
/*!HC:outArr1*/ double [] retArr = new /*!HC:outArr1*/ double [nrX];
/*!HC:outCls1*/ ILArray<double> ret = new /*!HC:outCls1*/ ILArray<double> (retArr,X.m_dimensions);
ILIterator</*!HC:inArr1*/ complex > it = X.CreateIterator(ILIteratorPositions.ILEnd,0);
for (int i= 0; i < nrX; i++) {
retArr[i] = it.Increment().real;
}
return ret;
}
/// <summary>
/// Multidimensional scaling/PCoA: transform distances to points in a coordinate system.
/// </summary>
/// <param name="input">A matrix of pairwise distances. Zero indicates identical objects.</param>
/// <returns>A matrix, the columns of which are coordinates in the nth dimension.
/// The rows are in the same order as the input.</returns>
public static ILArray<double> Scale(ILArray<double> input)
{
int n = input.Length;
ILArray<double> p = ILMath.eye<double>(n, n) - ILMath.repmat(1.0 / n, n, n);
ILArray<double> a = -.5 * ILMath.multiplyElem(input, input);
ILArray<double> b = ILMath.multiply(p, a, p);
ILArray<complex> V = ILMath.empty<complex>();
ILArray<complex> E = ILMath.eig((b + b.T) / 2, V);
ILArray<int> i = ILMath.empty<int>();
ILArray<double> e = ILMath.sort(ILMath.diag(ILMath.real(E)), i);
e = ILMath.flipud(e);
i = ILMath.toint32(ILMath.flipud(ILMath.todouble(i)));
ILArray<int> keep = ILMath.empty<int>();
for (int j = 0; j < e.Length; j++)
{
if (e[j] > 0.000000001)
{
keep.SetValue(j, keep.Length);
}
}
ILArray<double> Y;
if (ILMath.isempty(keep))
{
Y = ILMath.zeros(n, 1);
}
else
{
Y = ILMath.zeros<double>(V.S[0], keep.Length);
for (int j = 0; j < keep.Length; j++)
{
Y[ILMath.full, j] = ILMath.todouble(-V[ILMath.full, i[keep[j]]]) ;
}
Y = ILMath.multiply(Y, ILMath.diag(ILMath.sqrt(e[keep])));
}
ILArray<int> maxind = ILMath.empty<int>();
ILMath.max(ILMath.abs(Y), maxind, 0);
int d = Y.S[1];
ILArray<int> indices = maxind + ILMath.toint32(ILMath.array<int>(SteppedRange(0,n, (d-1)*n)));
ILArray<double> colsign = ILMath.sign(Y[indices]);
for (int j = 0; j < Y.S[1]; j++)
{
Y[ILMath.full, j] = Y[ILMath.full, j] * colsign[j];
}
return Y;
}
public static ILBaseArray convert(object type, ILArray<Double> X)
{
if (type.GetType() == typeof(IronPython.Runtime.Types.PythonType))
{
if (((IronPython.Runtime.Types.PythonType)type).__clrtype__() == typeof(Int32))
{
return convert(NumericType.Int32, X);
}
else return X;
}
else return X;
}
/// <summary>
/// convert arbitrary numeric array to arbitrary numeric type
/// </summary>
/// <param name="X">input array</param>
/// <param name="outputType">type description for return type</param>
/// <returns>converted array</returns>
/// <remarks> The newly created array will be converted to the type requested.
/// <para>Important note: if X matches the type requested, NO COPY will be made for it and the SAME array will be returned!</para></remarks>
public static ILBaseArray convert(NumericType outputType, ILArray</*!HC:inType1*/ double > X) {
if (outputType == /*!HC:inTypeName*/ NumericType.Double )
return X;
ILBaseArray ret = null;
switch (outputType) {
case NumericType.Double:
unsafe {
double [] retA = ILMemoryPool.Pool.New<double>(X.Dimensions.NumberOfElements);
fixed (double * pretA = retA)
fixed (/*!HC:inType1*/ double * pX = X.m_data) {
double * pStartR = pretA;
double * pEndR = pretA + X.m_data.Length;
/*!HC:inType1*/ double * pWalkX = pX;
while (pStartR < pEndR) {
*(pStartR++) = (double) *(pWalkX++);
}
}
ret = new ILArray<double> (retA,X.Dimensions);
}
return ret;
case NumericType.Complex:
unsafe {
complex [] retA = ILMemoryPool.Pool.New<complex>(X.Dimensions.NumberOfElements);
fixed (complex * pretA = retA)
fixed (/*!HC:inType1*/ double * pX = X.m_data) {
complex * pStartR = pretA;
complex * pEndR = pretA + X.m_data.Length;
/*!HC:inType1*/ double * pWalkX = pX;
while (pStartR < pEndR) {
*(pStartR++) = (complex) (*(pWalkX++));
}
}
ret = new ILArray<complex> (retA,X.Dimensions);
}
return ret;
case NumericType.Byte:
unsafe {
byte [] retA = ILMemoryPool.Pool.New<byte>(X.Dimensions.NumberOfElements);
fixed (byte * pretA = retA)
fixed (/*!HC:inType1*/ double * pX = X.m_data) {
byte * pStartR = pretA;
byte * pEndR = pretA + X.m_data.Length;
/*!HC:inType1*/ double * pWalkX = pX;
while (pStartR < pEndR) {
*(pStartR++) = (byte) *(pWalkX++);
}
}
ret = new ILArray<byte> (retA,X.Dimensions);
}
return ret;
}
return ret;
}
public static ILArray<double> cumsum(ILArray<double> X)
{
double[] outArray = ILMemoryPool.Pool.New<double>(X.m_dimensions.NumberOfElements);
double tally = 0;
for (int i = 0; i < outArray.Length; i++)
{
tally += X.m_data[i];
outArray[i] = tally;
}
return new ILArray<double>(outArray, X.m_dimensions);
}
internal static void turbinesCalculations(out double dTurb, out int nTurb, out double kWake, out ILArray<double> x, out int gridX, out int gridY, out ILArray<double> yOrder, out double dy, out ILArray<int> xTurbC, out ILArray<int> yTurbC, WindTurbineParameters parm, SimParm simParm)
{
#region "Used variables declaration"
ILArray<double> data;
double rotA;
int gridRes;
int endSize;
ILArray<double> y;
ILArray<double> xCoor;
ILArray<double> yCoor;
ILArray<double> xTurb;
ILArray<double> yTurb;
ILArray<double> xOrder;
int ppp;
ILArray<double> xGrid;
ILArray<double> yGrid;
#endregion
data = parm.wf.C;
dTurb = 2 * parm.radius._(1);
nTurb = parm.N;
rotA = parm.rotA;
kWake = parm.kWake;
gridRes = simParm.gridRes; // Grid Resolution, the lower the number, the higher the amount of points computed.
endSize = simParm.grid;
//if (Ct < 0) // !ILMath.isreal(Ct) |
{
//disp('Ct is negative or complex');
}
x = _c(1.0, gridRes, endSize);// x-grid.
y = _c(1.0, gridRes, endSize);// y-grid.
gridX = length(x); // Number of grid points.
gridY = length(y); // Number of grid points.
xCoor = data[_(':'), _(1)]; // Coordiante of turbine, x-position
yCoor = data[_(':'), _(2)]; // Coordinate of turbine, y-position
ROTATE_corrd(out xTurb, out yTurb, xCoor, yCoor, rotA); // Rotated (and scaled) coordinates
WT_order(out xOrder, out yOrder, xTurb, yTurb); // Ordered turbines.
ppp = 2; // This parameter is also a bit weird.. But it changes the grid.
DOMAIN_pt(out xGrid, out _double, gridX, dTurb, xOrder, ppp); //
ppp = 5;
DOMAIN_pt(out yGrid, out dy, gridY, dTurb, yOrder, ppp);
Turb_centr_coord(out xTurbC, nTurb, gridX, xGrid, xOrder, gridRes); // Determines the grid point closest to the turbine.
Turb_centr_coord(out yTurbC, nTurb, gridY, yGrid, yOrder, gridRes); // Determines the grid point closest to the turbine.
}
/// <summary>
/// Create new ILArray<double>, setting initial element values to one.
/// </summary>
/// <returns>Physical ILArray<double> with all elements set to one.</returns>
public static ILArray<double> ones(params int[] dimensions) {
ILDimension dim = new ILDimension(dimensions);
double[] data = ILMemoryPool.Pool.New<double>(dim.NumberOfElements);
ILArray<double> ret = new ILArray<double>(data, dimensions);
return set(ret, 1.0);
{/* unsafe {
fixed(double* pData = data) {
double* ende = pData + data.Length;
double* curr = pData;
while (curr < ende)
*curr++ = 1.0;
}*/
}
}
/// <summary>
/// Determine if matrix A is lower triangular matrix
/// </summary>
/// <param name="A">Matrix or scalar A of numeric inner type</param>
/// <returns>true if A is a lower triangular matrix, false otherwise</returns>
/// <exception cref="ILNumerics.Exceptions.ILArgumentException">if A was not a matrix or if A was null</exception>
public static bool istrilow(/*!HC:inCls1*/ ILArray<double> A) {
if (object.Equals(A,null))
throw new ILArgumentException ("istrilow: A must not be null!");
if (A.IsScalar) { return true; }
if (A.IsEmpty) { return false; }
if (!A.IsMatrix)
throw new ILArgumentException ("istrilow: A must be a matrix!");
int n = A.Dimensions[1];
for (int c = 1; c < n; c++) {
for (int r = 0; r < c; r++){
if (A.GetValue(r,c) != /*!HC:zerosVal*/ 0.0 ) return false;
}
}
return true;
}
/*!HC:TYPELIST:
<hycalper>
<type>
<source>
inCls1
</source>
<destination><![CDATA[ILArray<complex>]]></destination>
<destination><![CDATA[ILArray<float>]]></destination>
<destination><![CDATA[ILArray<fcomplex>]]></destination>
</type>
<type>
<source>
inCls2
</source>
<destination><![CDATA[ILArray<complex>]]></destination>
<destination><![CDATA[ILArray<float>]]></destination>
<destination><![CDATA[ILArray<fcomplex>]]></destination>
</type>
<type>
<source>
inArr1
</source>
<destination>complex</destination>
<destination>float</destination>
<destination>fcomplex</destination>
</type>
</hycalper>
*/
public static bool isequalwithequalnans(/*HC:inCls1*/ ILArray<double> A,/*HC:inCls2*/ ILArray<double> B) {
if (object.Equals(A,null) || object.Equals(B,null)) {
return !(object.Equals(A,null) ^ object.Equals(B,null));
}
if (A.IsEmpty && B.IsEmpty) return true;
if (!A.Dimensions.IsSameSize(B.Dimensions)) return false;
int pos = 0;
foreach (/*!HC:inArr1*/ double a in A.Values) {
/*!HC:inArr1*/ double b = B.GetValue(pos++);
if (/*!HC:inArr1*/ double .IsNaN(a) && /*!HC:inArr1*/ double .IsNaN(b)) continue;
if (/*!HC:inArr1*/ double .IsInfinity(a) && /*!HC:inArr1*/ double .IsInfinity(b)) continue;
if (b != a) return false;
}
return true;
}
/// <summary>
/// Creates the index of the shape indices.
/// </summary>
/// <param name="shapeIndices">The shape indices.</param>
/// <returns>index of shape indices</returns>
/// <remarks>The index of shape indices is used for fast facette lookup while (auto) creating
/// the normal vectors for the vertices. Therefore, the index of every vertex used in the shape
/// serves as index for a list of those facettes, where that vertex occures.
/// <para>TODO: may be replaced by a custom data structure in order to decrease memory requirements?</para></remarks>
public static Dictionary <int, List <int> > CreateShapeIndicesIndex(ILArray <int> shapeIndices)
{
Dictionary <int, List <int> > ret = new Dictionary <int, List <int> >();
int shapeCount = shapeIndices.Dimensions[1];
int vertPerShape = shapeIndices.Dimensions[0];
int curShapeIdx = 0;
int curRowIdx = 0;
foreach (int i in shapeIndices.Values)
{
if (!ret.ContainsKey(i))
{
ret.Add(i, new List <int>());
}
ret[i].Add(curShapeIdx);
curRowIdx++;
if (curRowIdx >= vertPerShape)
{
curRowIdx = 0;
curShapeIdx++;
}
}
return(ret);
}
public void Test_LDA_Performance1000x2000_100()
{
int errorCode = 0;
try {
LDA lda = new LDA();
ILArray <double> X = ILMath.horzcat(ILMath.randn(1000, 2000) * 2.0, ILMath.randn(1000, 2000) * -2.0);
ILLogicalArray labels = ILMath.tological(ILMath.horzcat(ILMath.ones(1, 2000), ILMath.zeros(1, 2000)));
labels = labels.Concat(ILMath.tological(ILMath.zeros(1, 2000).Concat(ILMath.ones(1, 2000), 1)), 0);
ILPerformer timer = new ILPerformer();
LDA.Hyperplane C;
int rep = 1;
timer.Tic();
for (int i = 0; i < rep; i++)
{
C = lda.TrainLDA(X, labels, 0.4);
}
timer.Toc();
Info("Test_LDA_Performance: data: 1000x4000 run " + rep.ToString() + " times in: " + timer.Duration + "ms");
Success();
}catch (Exception e) {
Error(errorCode, e.Message);
}
}
/// <summary>
/// Sinus of array elements
/// </summary>
/// <param name="A">input array</param>
/// <returns>Sinus of elements from input array</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static /*!HC:outCls*/ ILArray <double> /*!HC:HCfuncname*/ sin(/*!HC:inCls1*/ ILArray <double> A)
{
if (A.IsEmpty)
{
return /*!HC:outCls*/ (ILArray <double> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
/*!HC:outArr*/ double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new /*!HC:outArr*/ double [newLength];
retDblArr = ILMemoryPool.Pool.New </*!HC:outArr*/ double> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(/*!HC:outArr*/ double *pOutArr = retDblArr)
fixed(/*!HC:inArr1*/ double *pInArr = A.m_data)
{
/*!HC:outArr*/ double *lastElement = pOutArr + retDblArr.Length;
/*!HC:outArr*/ double *tmpOut = pOutArr;
/*!HC:inArr1*/ double *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
/*!HC:HCCompute02*/
{
*tmpOut++ = /*!HC:HCoperation*/ Math.Sin(*tmpIn++) /*!HC:HCpostOp*/;
}
}
}
return(new /*!HC:outCls*/ ILArray <double> (retDblArr, inDim));
}
/// <summary>
/// Determine if matrix A is upper Hessenberg matrix
/// </summary>
/// <param name="A">Matrix or scalar A of numeric inner type</param>
/// <returns>true if A is a upper Hessenberg matrix, false otherwise</returns>
/// <exception cref="ILNumerics.Exceptions.ILArgumentException">if A was null</exception>
public static bool ishessup(/*!HC:inCls1*/ ILArray <double> A)
{
if (object.Equals(A, null))
{
throw new ILArgumentException("ishessup: A must not be null!");
}
if (A.IsScalar)
{
return(true);
}
if (A.IsEmpty)
{
return(false);
}
if (!A.IsMatrix)
{
return(false);
}
int n = A.Dimensions[1];
if (n != A.Dimensions[0])
{
return(false);
}
for (int c = 0; c < n - 2; c++)
{
for (int r = c + 2; r < n; r++)
{
if (A.GetValue(r, c) != /*!HC:zerosVal*/ 0.0)
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Determine if matrix A is Hermitian matrix
/// </summary>
/// <param name="A">Matrix or scalar A of numeric inner type</param>
/// <returns>true if A is a Hermitian matrix, false otherwise</returns>
/// <exception cref="ILNumerics.Exceptions.ILArgumentException">if A was null</exception>
public static bool ishermitian(ILArray <byte> A)
{
if (object.Equals(A, null))
{
throw new ILArgumentException("ishessup: A must not be null!");
}
if (A.IsScalar)
{
return(true);
}
if (A.IsEmpty)
{
return(false);
}
if (!A.IsMatrix)
{
return(false);
}
int n = A.Dimensions[1];
if (n != A.Dimensions[0])
{
return(false);
}
for (int c = 0; c < n; c++)
{
for (int r = c + 1; r < n; r++)
{
if (A.GetValue(r, c) != A.GetValue(c, r))
{
return(false);
}
}
}
return(true);
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>Cosine of array elements</summary>
/// <param name="A">input array</param>
/// <returns>Cosine of array elements</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILArray <complex> cos(ILArray <complex> A)
{
if (A.IsEmpty)
{
return(ILArray <complex> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
complex [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new complex [newLength];
retDblArr = ILMemoryPool.Pool.New <complex> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(complex *pOutArr = retDblArr)
fixed(complex * pInArr = A.m_data)
{
complex *lastElement = pOutArr + retDblArr.Length;
complex *tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = complex.Cos(*tmpIn++);
}
}
}
return(new ILArray <complex> (retDblArr, inDim));
}
/// <summary>
/// Rank of matrix inArray
/// </summary>
/// <param name="inArray">Matrix</param>
/// <param name="tolerance">tolerance used to decide, if a singular value is
/// treated as zero</param>
/// <returns>rank of matrix inArray</returns>
/// <remarks>The rank is the number of singular values greater than
/// tolerance. If tolerance is smaller than zero, the following equation is used as
/// default: \\
/// tol = length(inArray) * norm(inArray) * Double.epsilon \\
/// with
/// <list type="bullet">
/// <item>length(inArray) - the longest dimension of inArray</item>
/// <item>norm(inArray) beeing the largest singular value of inArray, </item>
/// <item>Double.epsilon - the smallest number greater than zero</item>
/// </list>
/// </remarks>
public static ILArray <double> rank(ILArray <double> inArray, double tolerance)
{
if (inArray.Dimensions.NumberOfDimensions > 2)
{
throw new ILArgumentSizeException("rank: the input array must be matrix or vector!");
}
ILArray <double> ret = svd(inArray);
if (tolerance < 0)
{
tolerance = inArray.Dimensions.Longest * max(ret).GetValue(0) * System.Double.Epsilon;
}
// count vector elements: ret must (and will) be physical vector returned from svd
double count = 0.0;
foreach (double d in ret.Values)
{
if (d > tolerance)
{
count++;
}
}
return(new ILArray <double>(count));
}
public static ILArray <float> CreateData(int rX, int rY)
{
Bitmap heightmap = Resource1.saltlake;
int x = Math.Min(heightmap.Size.Width, rX);
int y = Math.Min(heightmap.Size.Height, rY);
ILArray <float> ret = new ILArray <float>(rX, rY);
for (int c = 0; c < x; c++)
{
for (int r = 0; r < y; r++)
{
Color val = heightmap.GetPixel(c, r);
ret.SetValue(val.GetBrightness(), r, c);
}
}
float maxVal = (float)maxall(abs(ret));
if (maxVal != 0)
{
ret /= maxVal;
}
ret *= 50;
return(ret); // ["0:2:end;0:2:end"];
}
public static ILArray <double> cross(ILArray <double> A, ILArray <double> B, int dim)
{
// Input checking
if (!A.m_dimensions.IsSameShape(B.m_dimensions))
{
throw new ILDimensionMismatchException("Inputs must have the same size and shape.");
}
ILDimension outDims = A.m_dimensions;
double[] outArray = ILMemoryPool.Pool.New <double>(outDims.NumberOfElements);
if (dim >= outDims.NumberOfDimensions || dim < 0)
{
throw new Exception("Specified dim is out of bounds of the array!");
}
if (outDims[dim] != 3)
{
throw new Exception("Must have length 3 in the dimension where the cross product is taken.");
}
// Cross Product
int SID = outDims.SequentialIndexDistance(dim);
int crosses = outDims.NumberOfElements / 3;
int SID2 = 2 * SID;
for (int i = 0; i < crosses; i++)
{
outArray[i] = A.m_data[SID + i] * B.m_data[SID2 + i] - A.m_data[SID2 + i] * B.m_data[SID + i];
outArray[SID + i] = A.m_data[SID2 + i] * B.m_data[i] - A.m_data[i] * B.m_data[SID2 + i];
outArray[SID2 + i] = A.m_data[i] * B.m_data[SID + i] - A.m_data[SID + i] * B.m_data[i];
}
return(new ILArray <double>(outArray, outDims));
}
/// <summary>Locate infinite value elements</summary>
/// <param name="A">input array</param>
/// <returns>Logical array with 1 if the corresponding elements of input array is infinite, 0 else.</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILLogicalArray isinf(ILArray <complex> A)
{
if (A.IsEmpty)
{
return(ILLogicalArray.empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
byte [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new byte [newLength];
retDblArr = ILMemoryPool.Pool.New <byte> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(byte *pOutArr = retDblArr)
fixed(complex * pInArr = A.m_data)
{
byte * lastElement = pOutArr + retDblArr.Length;
byte * tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = complex.IsInfinity(*tmpIn++) ?(byte)1:(byte)0;
}
}
}
return(new ILLogicalArray(retDblArr, inDim));
}
public void ILArrayToFile(ILArray <double> ilarray, int dimensionX, int dimensionY)
{
double[,] array = this.GetTwoDimensionalArray(ilarray, dimensionX, dimensionY);
StringBuilder sb = new StringBuilder();
sb.Append("{");
for (int i = 0; i < dimensionX; i++)
{
sb.Append("{");
for (int j = 0; j < dimensionY; j++)
{
sb.Append(array[i, j].ToString());
if (j < dimensionY - 1)
{
sb.Append(",");
}
}
sb.Append("}");
if (i < dimensionX - 1)
{
sb.Append(",");
}
sb.Append("\r\n");
}
sb.Append("}");
File.WriteAllText(@"D:/TestMatrix.txt", sb.ToString());
}
// code to create the weight
// Basically only a circle is created and corresponding indices for the quad mappings
internal static ILCell CreatePendulaWeight()
{
// weigth midpoint
maxAlpha *= 0.999999;
double a1 = Math.Sin(DateTime.Now.TimeOfDay.TotalMilliseconds / 1000) * maxAlpha;
double xPos = pLength * Math.Sin(a1);
double yPos = pLength * Math.Cos(a1);
// create circle for weight
ILArray <double> alpha = linspace(0, 2 * pi, vLen);
ILArray <double> coord = vertcat(
cos(alpha) + xPos,
pLength - sin(alpha) - yPos,
zeros(1, vLen));
// create mapping for weight edges (quads)
ILArray <double> maps = counter(0.0, 1.0, 1, vLen - 1);
maps = vertcat(maps, maps + 1, maps + vLen + 1, maps + vLen);
// wrap all arrays into an ILCell
return(new ILCell(new ILBaseArray[] { coord, maps }, 1, 2));
}
/// <summary>Arctangent of array elements </summary>
/// <param name="A">input array</param>
/// <returns>Arctangent of array elements</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILArray <double> atan(ILArray <double> A)
{
if (A.IsEmpty)
{
return(ILArray <double> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new double [newLength];
retDblArr = ILMemoryPool.Pool.New <double> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(double *pOutArr = retDblArr)
fixed(double *pInArr = A.m_data)
{
double *lastElement = pOutArr + retDblArr.Length;
double *tmpOut = pOutArr;
double *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = Math.Atan(*tmpIn++);
}
}
}
return(new ILArray <double> (retDblArr, inDim));
}
private void SetExampleScene(ILPanel panel)
{
ILScene scene = new ILScene();
try {
ILLabel.DefaultFont = new System.Drawing.Font("Helvetica", 8);
//ilPanel1.Driver = RendererTypes.GDI;
#region upper left plot
// prepare some data
ILArray <float> P = 1,
x = ILMath.linspace <float>(-2, 2, 40),
y = ILMath.linspace <float>(2, -2, 40);
ILArray <float> F = ILMath.meshgrid(x, y, P);
// a simple RBF
ILArray <float> Z = ILMath.exp(-(1.2f * F * F + P * P));
// surface expects a single matrix
Z[":;:;2"] = F; Z[":;:;1"] = P;
// add a plot cube
var pc = scene.Add(new ILPlotCube {
// shrink viewport to upper left quadrant
ScreenRect = new RectangleF(0.05f, 0, 0.4f, 0.5f),
// 3D rotation
TwoDMode = false,
Children =
{
// add surface
new ILSurface(Z)
{
// disable mouse hover marking
Fill = { Markable = false },
Wireframe ={ Markable = false },
// make it shiny
UseLighting = true,
Children = { new ILColorbar() }
},
//ILLinePlot.CreateXPlots(Z["1:10;:;0"], markers: new List<MarkerStyle>() {
// MarkerStyle.None,MarkerStyle.None,MarkerStyle.None,MarkerStyle.None,MarkerStyle.Circle, MarkerStyle.Cross, MarkerStyle.Plus, MarkerStyle.TriangleDown }),
//new ILLegend("hi","n","ku","zs","le", "blalblalblalblalb\\color{red} hier gehts rot")
},
Rotation = Matrix4.Rotation(new Vector3(1.1f, -0.4f, -0.69f), 1.3f)
});
#endregion
#region top right plot
// create a gear shape
var gear = new ILGear(toothCount: 30, inR: 0.5f, outR: 0.9f)
{
Fill = { Markable = false, Color = Color.DarkGreen }
};
// group with right clipping plane
var clipgroup = new ILGroup()
{
Clipping = new ILClipParams()
{
Plane0 = new Vector4(1, 0, 0, 0)
},
Children =
{
// a camera holding the (right) clipped gear
new ILCamera()
{
// shrink viewport to upper top quadrant
ScreenRect = new RectangleF(0.5f, 0, 0.5f, 0.5f),
// populate interactive changes back to the global scene
IsGlobal = true,
// adds the gear to the camera
Children ={ gear },
Position = new Vector3(0, 0, -15)
}
}
};
// setup the scene
var gearGroup = scene.Add(new ILGroup {
clipgroup, clipgroup // <- second time: group is cloned
});
gearGroup.First <ILCamera>().Parent.Clipping = new ILClipParams()
{
Plane0 = new Vector4(-1, 0, 0, 0)
};
// make the left side transparent green
gearGroup.First <ILTriangles>().Color = Color.FromArgb(100, Color.Green);
// synchronize both cameras; source: left side
gearGroup.First <ILCamera>().PropertyChanged += (s, arg) => {
gearGroup.Find <ILCamera>().ElementAt(1).CopyFrom(s as ILCamera, false);
};
#endregion
#region left bottom plot
// start value
int nrBalls = 10; bool addBalls = true;
var balls = new ILPoints("balls")
{
Positions = ILMath.tosingle(ILMath.randn(3, nrBalls)),
Colors = ILMath.tosingle(ILMath.rand(3, nrBalls)),
Color = null,
Markable = false
};
var leftBottomCam = scene.Add(new ILCamera {
ScreenRect = new RectangleF(0, 0.5f, 0.5f, 0.5f),
Projection = Projection.Perspective,
Children = { balls }
});
// funny label
string harmony = @"\color{red}H\color{blue}a\color{green}r\color{yellow}m\color{magenta}o\color{cyan}n\color{black}y\reset
";
var ballsLabel = scene.Add(new ILLabel(tag: "harmony")
{
Text = harmony,
Fringe = { Color = Color.FromArgb(240, 240, 240) },
Position = new Vector3(-0.75f, -0.25f, 0)
});
long oldFPS = 1;
PointF currentMousePos = new PointF();
// setup the swarm. Start with a few balls, increase number
// until framerate drops below 60 fps.
ILArray <float> velocity = ILMath.tosingle(ILMath.randn(3, nrBalls));
EventHandler <ILRenderEventArgs> updateBallsRenderFrame = (s, arg) => {
// transform viewport coords into 3d scene coords
Vector3 mousePos = new Vector3(currentMousePos.X * 2 - 1,
currentMousePos.Y * -2 + 1, 0);
// framerate dropped? -> stop adding balls
if (panel.FPS < oldFPS && panel.FPS < 60)
{
addBalls = false;
}
oldFPS = panel.FPS;
Computation.UpdateBalls(mousePos, balls, velocity, addBalls);
// balls buffers have been changed -> must call configure() to publish
balls.Configure();
// update balls label
ballsLabel.Text = harmony + "(" + balls.Positions.DataCount.ToString() + " balls)";
};
// saving the mouse position in MouseMove is easier for
// transforming the coordinates into the viewport
leftBottomCam.MouseMove += (s, arg) => {
// save the mouse position
currentMousePos = arg.LocationF;
};
panel.BeginRenderFrame += updateBallsRenderFrame;
m_cleanUpExample = () => {
leftBottomCam.MouseMove -= (s, arg) => {
// save the mouse position
currentMousePos = arg.LocationF;
};
panel.BeginRenderFrame -= updateBallsRenderFrame;
};
#endregion
panel.Scene = scene;
} catch (Exception exc) {
System.Diagnostics.Trace.WriteLine("ILPanel_Load Error:");
System.Diagnostics.Trace.WriteLine("====================");
System.Diagnostics.Trace.WriteLine(exc.ToString());
MessageBox.Show(exc.ToString());
}
}
private ILArray <double> calculateDispersion(double[,] matrix)
{
ILArray <double> tmp = matrix;
return(((double[, ])MachineLearning.Learning.Regression.FeatureSubsetSelection.toSystemMatrix <double>((ILMath.multiply(tmp, tmp.T)))).PseudoInverse());
}
protected static ILArray <double> sum(ILArray <double> ilArray)
{
return(ILMath.sum(ilArray));
}
protected static double sum_(ILArray <double> ilArray)
{
ILArray <double> result = sum(ilArray);
return(result._Scalar());
}
protected static ILArray <double> reshape(ILArray <double> ilArray, int dim1, int dim2)
{
return(ILMath.reshape(ilArray, dim1, dim2));
}
protected static ILArray <double> mean(ILArray <double> ilArray)
{
return(ILMath.mean(ilArray));
}
protected static ILArray <double> transpose(ILArray <double> ilArray)
{
return(ilArray.T);
}
protected static ILArray <double> max(ILArray <double> ilArray, double value)
{
return(ILMath.max(ilArray, value));
}
/// <summary>
/// Matrix multiplication
/// </summary>
/// <param name="star">'*'</param>
protected static ILArray <double> _m(ILArray <double> ilArray1, char star, ILArray <double> ilArray2)
{
return(ILMath.multiply(ilArray1, ilArray2));
}
/// <summary>
/// Matrix division (matrix equation A * X = B solving)
/// </summary>
/// <param name="star">'\'</param>
protected static ILArray <double> _s(ILArray <double> ilArray1, char backslash, ILArray <double> ilArray2)
{
return(ILMath.linsolve(ilArray1, ilArray2));
}
protected static ILArray <int> _int(ILArray <double> ilArray)
{
return(ILMath.toint32(ilArray));
}
protected static ILArray <double> _dbl(ILArray <int> ilArray)
{
return(ILMath.todouble(ilArray));
}
//protected static bool isempty<T>(ILArray<T> ilArray)
//{
// return ILMath.isempty(ilArray);
//}
protected static bool isempty(ILArray <double> ilArray)
{
return(ILMath.isempty(ilArray));
}
private double calcVarianceForRunIL(double[] run, ILArray <double> dispersion)
{
ILArray <double> vector = run;
return((double)ILMath.multiply(ILMath.multiply(vector.T, dispersion), vector));
}
protected static ILArray <double> inv(ILArray <double> ilArray)
{
return(ILMath.pinv(ilArray));
}
public bool compute(int _sampleSize, int _k)
{
if (options.Count == 0)
{
return(false);
}
// set number of possible levels for each VariableFeature
numberOfLevels = new Dictionary <NumericOption, int>();
foreach (NumericOption numOption in options)
{
optionToIndex.Add(numOption, optionToIndex.Count);
List <double> allValuesOfOption = numOption.getAllValues();
optionToValues.Add(numOption, allValuesOfOption);
int posLevels = allValuesOfOption.Count;
if (!rescale || posLevels <= 4) // include all levels if # <= 4
{
numberOfLevels.Add(numOption, posLevels);
}
else
{
numberOfLevels.Add(numOption, Convert.ToInt32(4 + Math.Round(Math.Sqrt(posLevels) / 2.0))); // rescale
}
}
// get full factorial design
double[,] fullFactorial = getFullFactorial(numberOfLevels);
fullFactorial = filterByNonBooleanconstraints(fullFactorial);
// create initial random design
Random rnd = new Random(1);
Dictionary <int, int> usedCandidates = new Dictionary <int, int>();
matrix = new double[_sampleSize, options.Count];
// chose initial candidates from full factorial
do
{
if (usedCandidates.Count >= _sampleSize)
{
break;
}
int candidate = rnd.Next(0, fullFactorial.GetLength(0));
if (!usedCandidates.Values.Contains(candidate))
{
int tmp = usedCandidates.Count;
setRowOfMatrixTo(matrix, tmp, fullFactorial, candidate);
usedCandidates.Add(tmp, candidate);
}
} while (true);
// Calculate dispersion matrix
ILArray <double> dispersion = calculateDispersion(matrix);
// start of k-Exchange algorithm
bool couplesWithPositiveDelta = true;
while (couplesWithPositiveDelta)
{
Dictionary <int, double> variances = new Dictionary <int, double>();
for (int i = 0; i < matrix.GetLength(0); i++)
{
variances.Add(i, calcVarianceForRunIL(getRowFromMatrix(matrix, i), dispersion));
}
couplesWithPositiveDelta = false;
foreach (KeyValuePair <int, double> v in variances.OrderByDescending(p => p.Value).Take(_k))
{
// Get deltas for exchange
Dictionary <int, double> deltaF = getAllDeltas(usedCandidates[v.Key], fullFactorial);
// Get rid of duplicates
deltaF = deltaF.Where(c => !usedCandidates.Values.Contains(c.Key)).ToDictionary(dict => dict.Key, dict => dict.Value);
// Get exchange candidates
KeyValuePair <int, double> eF = deltaF.OrderByDescending(p => p.Value).First();
if (eF.Value > epsilon)
{
setRowOfMatrixTo(matrix, v.Key, fullFactorial, eF.Key);
usedCandidates[v.Key] = eF.Key;
dispersion = calculateDispersion(matrix);
couplesWithPositiveDelta = true;
}
}
}
// map configuration to valid values that can be passed to the software
Dictionary <Tuple <NumericOption, int>, double> values = new Dictionary <Tuple <NumericOption, int>, double>();
foreach (NumericOption opt in options)
{
int maxVal = numberOfLevels[opt] - 1;
double delta = opt.Max_value - opt.Min_value;
for (int i = 0; i <= maxVal; i++)
{
double value = opt.Min_value + (i / (double)maxVal) * delta;
value = opt.nearestValidValue(value);
values.Add(Tuple.Create(opt, i), value);
}
}
List <Dictionary <NumericOption, double> > configs = new List <Dictionary <NumericOption, double> >();
for (int i = 0; i < matrix.GetLength(0); i++)
{
Dictionary <NumericOption, double> run = new Dictionary <NumericOption, double>();
int j = 0;
foreach (NumericOption vf in options)
{
run.Add(vf, values[Tuple.Create(vf, Convert.ToInt32(matrix[i, j]))]);
j++;
}
configs.Add(run);
}
this.selectedConfigurations = configs;
return(true);
}
protected static double max_(ILArray <double> ilArray)
{
ILArray <double> result = MatlabCode.max(ilArray);
return(result._Scalar());
}