/// <summary> /// Smaller operator of <![CDATA[ILArray<>]]> with scalar /// </summary> /// <param name="in1">ILArray</param> /// <param name="in2">Scalar</param> /// <returns>ILLogicalArray of same size than in1, with elements having 'true' values /// for all corresponding elements of in1 beeing smaller in2, false if they are not. /// </returns> /// <remarks>This operator is overloaded for /// all numeric types of <![CDATA[ILArray<>]]> for in1. The type of in2 is always double. </remarks> public static ILLogicalArray operator <(ILArray <BaseT> in1, double in2) { if (false) { #region HYCALPER LOOPSTART } else if (in1 is /*!HC:inCls1*/ ILArray <double> ) { return(ILMath.lt(in1 as /*!HC:inCls1*/ ILArray <double>, (/*!HC:inArr2*/ double )in2)); #endregion HYCALPER LOOPEND #region HYCALPER AUTO GENERATED CODE // DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !! } else if (in1 is ILArray <complex> ) { return(ILMath.lt(in1 as ILArray <complex>, ( complex )in2)); } else if (in1 is ILArray <byte> ) { return(ILMath.lt(in1 as ILArray <byte>, ( byte )in2)); #endregion HYCALPER AUTO GENERATED CODE } else { throw new ILArgumentTypeException("Operator '<' is not defined for ILArrays of type " + in1.GetType().Name); } }
public static void forwBackwCheck2D(ILArray <double> A, ILArray <complex> Result) { try { ILArray <complex> B = fft2(A); //double errMult = 1/(A.Dimensions.NumberOfElements * Math.Pow(10,A.Dimensions.NumberOfDimensions)); double errMult = Math.Pow(0.1, A.Dimensions.NumberOfDimensions) / A.Dimensions.NumberOfElements; if (!A.IsScalar) { errMult /= (double)A.Dimensions[A.Dimensions.FirstNonSingleton()]; } if (sumall(abs(subtract(Result, B))) * errMult > (double)MachineParameterDouble.eps) { throw new Exception("invalid value"); } ILArray <double> ResultR = ifft2sym(B); if (ILMath.sumall(ILMath.abs(ResultR - A)) * errMult > (double)ILMath.MachineParameterDouble.eps) { throw new Exception("invalid value"); } B = ifft2(B); if (ILMath.sumall(ILMath.abs(ILMath.tocomplex(A) - B)) * errMult > (double)ILMath.MachineParameterDouble.eps) { throw new Exception("invalid value"); } } catch (ILNumerics.Exceptions.ILArgumentException) { throw new Exception("unexpected exception was thrown -> error!"); } }
//protected static bool isempty(string str) //{ // return (str == string.Empty); //} protected static double randn() { //get { return((double)(ILMath.randn())); } }
/// <summary> /// For optimization, we generate a column for the data matrix only once. The rows of the columns represent the configurations of the learning set. /// The cells contain the value of the feature in the respective configuration. (see comment on createDataMatrix(..) function for more detail). /// </summary> /// <param name="feature">The feature for which we compute the data column.</param> protected void generateDM_column(Feature feature) { ILArray <double> column = ILMath.zeros(this.learningSet.Count); if (feature.participatingBoolOptions.Count == 1 && feature.participatingNumOptions.Count == 0 && feature.participatingBoolOptions.Contains(this.infModel.Vm.Root)) { for (int r = 0; r < this.learningSet.Count; r++) { column[r] = 1; } this.DM_columns.Add(feature, column); return; } int i = 0; foreach (Configuration config in this.learningSet) { if (feature.validConfig(config)) { column[i] = feature.eval(config); } i++; } this.DM_columns.Add(feature, column); }
public void MeasurePool() { Info("Measuring memory pool performance"); Info("---------------------------------"); ILArray <int> Lengths = ILMath.toint32(ILMath.vector(1000000, 1000, 1000000)); ILArray <int> PoolSizes = ILMath.toint32(ILMath.vector(00, 10, 250)); ILArray <double> result = ILMath.zeros(Lengths.Length, PoolSizes.Length); ILArray <double> dataA = ILMath.ones(1000, 1000); ILArray <double> dataB = ILMath.ones(1000, 1000); int counter = 1, countAll = Lengths.Length * PoolSizes.Length; for (int p = 0; p < PoolSizes.Length; p++) { for (int s = 0; s < Lengths.Length; s++) { result[s, p] = MeasurePoolParameter((int)Lengths[s], (int)PoolSizes[p], 100, dataA, dataB); Console.Out.Write(String.Format("\r... step {0} of {1} completed", counter++, countAll)); } } result.Name = "results"; ILMatFile mf = new ILMatFile(); mf["results"] = result; mf["lengths"] = Lengths; mf["poolSizes"] = PoolSizes; mf.Write(new FileStream("memoryPoolTestPerf.mat", FileMode.Create)); }
private void TestQuickSortGen(ILArray <double> input, int dim, bool desc) { try { ILArray <int> A = ILMath.toint32(input); try { ILMatFile f1 = new ILMatFile("tempADebugQuickSort.mat"); A = (ILArray <int>)f1["DebugQuickSort"]; } catch (Exception) {} ILArray <int> result; System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); result = ILMath.sort(A, dim, desc); sw.Stop(); if (!isSorted(ILMath.todouble(result), dim, desc)) { //ILMatFile f = new ILMatFile(); //A.Name = "DebugQuickSort"; //f.Add(A); //System.IO.Stream s = new System.IO.FileStream("tempADebugQuickSort.mat",System.IO.FileMode.CreateNew); //f.Write(s); throw new Exception("invalid values"); } Success(input.Dimensions.ToString() + "(Int32) needed: " + sw.ElapsedMilliseconds + " ms"); } catch (Exception e) { Error(0, e.Message); } }
public void Test_LDA_Performance2000_var(int rep) { int errorCode = 0; try { LDA lda = new LDA(); ILArray <double> X = ILMath.horzcat(ILMath.randn(2, 2000) * 2.0, ILMath.randn(2, 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 oldRefMin = ILNumerics.Settings.ILSettings.MinimumRefDimensions; ILNumerics.Settings.ILSettings.MinimumRefDimensions = 2; timer.Tic(); for (int i = 0; i < rep; i++) { C = lda.TrainLDA(X, labels, 0.4); } timer.Toc(); Info("Test_LDA_Performance: with reference - data: 2x2000 run " + rep.ToString() + " times in: " + timer.Duration + "ms"); ILNumerics.Settings.ILSettings.MinimumRefDimensions = 3; timer.Tic(); for (int i = 0; i < rep; i++) { C = lda.TrainLDA(X, labels, 0.4); } timer.Toc(); ILNumerics.Settings.ILSettings.MinimumRefDimensions = oldRefMin; Info("Test_LDA_Performance: without reference - data: 2x2000 run " + rep.ToString() + " times in: " + timer.Duration + "ms"); Success(); }catch (Exception e) { Error(errorCode, e.Message); } }
// Initial plot setup, modify this as needed private void ilPanel1_Load(object sender, EventArgs e) { // create some test data, using our private computation module as inner class ILArray <float> Pos = Computation.CreateData(4, 300); // setup the plot (modify as needed) ilPanel1.Scene.Add(new ILPlotCube(twoDMode: false) { new ILLinePlot(Pos, tag: "mylineplot") { Line = { Width = 2, Color = Color.Red, Antialiasing = true, DashStyle = DashStyle.Dotted } } }); // register event handler for allowing updates on right mouse click: ilPanel1.Scene.First <ILLinePlot>().MouseClick += (_s, _a) => { if (_a.Button == MouseButtons.Right) { Update(ILMath.rand(3, 30)); } }; }
// Initial plot setup, modify this as needed private void ilPanel1_Load(object sender, EventArgs e) { // setup the plot (modify as needed) ilPanel1.Scene.Add(new ILPlotCube(twoDMode: false) { new ILLinePlot(Points, tag: "points") { Line = { Width = 2, Color = Color.Red, Antialiasing = true, DashStyle = DashStyle.Dotted } }, new ILLinePlot(PointsPerceptron, tag: "points") { Line = { Width = 2, Color = Color.Blue, Antialiasing = true, DashStyle = DashStyle.Dotted } } }); // register event handler for allowing updates on right mouse click: ilPanel1.Scene.First <ILLinePlot>().MouseClick += (_s, _a) => { if (_a.Button == MouseButtons.Right) { Update(ILMath.rand(3, 30)); } }; }
/// <summary> /// Computes FFT for the given sampleset. /// </summary> /// <param name="Samples">Sampleset on which to compute a FFT</param> public FFT(List <double> Samples, List <BandFrequencyDefinition> CustomBands = null) { using (ILScope.Enter()) { ILInArray <double> inArr = Samples.ToArray(); ILRetArray <complex> output = ILMath.fft(inArr); rawFFTOutput = output.ToArray(); } ComputeFrequencyPowerSamples(); //FrequencyBands ComputeAbsoluteBandPower(BandFrequencyDefinition.Delta); ComputeAbsoluteBandPower(BandFrequencyDefinition.Theta); ComputeAbsoluteBandPower(BandFrequencyDefinition.Alpha); ComputeAbsoluteBandPower(BandFrequencyDefinition.Beta); ComputeAbsoluteBandPower(BandFrequencyDefinition.Gamma); if (CustomBands != null) { foreach (BandFrequencyDefinition customBand in CustomBands) { ComputeAbsoluteBandPower(customBand); } } }
public ILArray </*!HC:HCretArr*/ complex> /*!HC:funcName*/ FFTForward(ILArray </*!HC:HCinArr*/ double> A, int firstDim, int nDims) { if (A == null || nDims < 0 || firstDim < 0) { throw new ILArgumentException("invalid parameter!"); } if (A.IsEmpty) { return(ILArray </*!HC:HCretArr*/ complex> .empty(A.Dimensions)); } if (A.IsScalar || (A.Dimensions[firstDim] == 1 && nDims == 1)) { return /*!HC:convRet*/ (ILMath.tocomplex(A)); } if (nDims > A.Dimensions.NumberOfDimensions) { nDims = A.Dimensions.NumberOfDimensions; } // prepare output array ILArray </*!HC:HCretArr*/ complex> ret = /*!HC:convRet*/ ILMath.tocomplex(A); IntPtr plan = IntPtr.Zero; int hrank = 2; FFTW_DIRECTION dir = /*!HC:HCdir*/ FFTW_DIRECTION.FORWARD; lock (_lockobject) { FFTW_PLANCREATION flags = FFTW_PLANCREATION.ESTIMATE; if (nDims > m_n.Length) { resizeCache(nDims); } for (int i = 0; i < nDims; i++) { m_n[i] = A.Dimensions[i + firstDim]; m_is[i] = A.Dimensions.SequentialIndexDistance(i + firstDim); m_os[i] = m_is[i]; } m_hn[0] = A.Dimensions.SequentialIndexDistance(firstDim); m_his[0] = 1; m_hos[0] = 1; m_his[1] = A.Dimensions.SequentialIndexDistance(nDims + firstDim); m_hn[1] = A.Dimensions.NumberOfElements / m_his[1]; m_hos[1] = m_his[1]; fixed(/*!HC:HCretArr*/ complex *retArr = ret.m_data) { /*!HC:HCplanfun*/ dfftw_plan_guru_dft_(ref plan, ref nDims, m_n, m_is, m_os, ref hrank, m_hn, m_his, m_hos, retArr, retArr, ref dir, ref flags); } } if (plan == IntPtr.Zero) { throw new ILInvalidOperationException("error creating plan for fftw3 (guru interface)"); } dfftw_execute_(ref plan); dfftw_destroy_plan_(ref plan); /*!HC:HCbackwScale*/ return(ret); }
private void PlotSurfaceBtn_Click(object sender, RoutedEventArgs e) { var B = ILMath.tosingle(sigma); var scene = new PlotCube(twoDMode: false) { // add a surface new Surface(B) { // make thin transparent wireframes Wireframe = { Color = Color.FromArgb(50, Color.LightGray) }, // choose a different colormap Colormap = Colormaps.Jet, } }; scene.Axes.XAxis.Max = (float)arguments[0].Maximum; scene.Axes.XAxis.Min = (float)arguments[0].Minimum; scene.Axes.YAxis.Max = (float)arguments[1].Maximum; scene.Axes.YAxis.Min = (float)arguments[1].Minimum; scene.First <PlotCube>().Rotation = Matrix4.Rotation(new Vector3(1f, 0.23f, 1), 0.7f); PlotSurface form = new PlotSurface(scene); form.Refresh(); form.ShowDialog(); }
public ILArray <double> GetInverseMatrixOfMatrix(ILArray <double> inputMatrix, int dimension) { ILArray <double> identityMatrix = ILMath.eye(dimension, dimension); ILArray <double> inverseCovMatrix = ILMath.linsolve(inputMatrix, identityMatrix); return(inverseCovMatrix); }
public double GetSDNLL_MDF(ILArray <double> mdfVector) { double firstPart = 0; double secondPart = 0; double thirdPart = 0; if (this.items.Count < 2) { this.covarianceMatrixMDF = this.GetVarianceMatrix_MDF(); } int q = this.meanMDF.Length; // get matrix W ILArray <double> W = this.GetMatrixW_MDF(); ILArray <double> WInverse = this.GetInverseMatrixOfMatrix(W, q); /*if (Double.IsNaN(WInverse.ToArray()[0])) * { * //throw new InvalidDataException("inverse of covariance matrix MDF is NaN"); * WInverse = ILMath.eye(this.parent.VarianceMDF.Length, this.parent.VarianceMDF.Length); * Debug.Assert(true, "Problem with covariance gaussian matrix."); * }*/ ILArray <double> vector1 = mdfVector - this.meanMDF; ILArray <double> tmpArray = ILMath.multiply(WInverse, vector1); firstPart = 0.5 * ILMath.multiply(vector1.T, tmpArray).ToArray()[0]; secondPart = q / 2 * ILMath.log(2 * Math.PI).ToArray()[0]; thirdPart = 0.5 * ILMath.log(ILMath.det(W)).ToArray()[0]; return(firstPart + secondPart + thirdPart); }
private static void sortIDXTestHelper001(int dim, int[] dims, ref ILArray <double> expectInd, int[] dimsEx) { int i; for (i = 0; i < dimsEx.Length; i++) { if (i <= dim) { dimsEx[i] = dims[i]; } else { dimsEx[i] = 1; } } expectInd = ILMath.reshape(expectInd, dimsEx); for (i = 0; i < dimsEx.Length; i++) { if (i <= dim) { dimsEx[i] = 1; } else { dimsEx[i] = dims[i]; } } }
public ILArray <T> Load <T>() { int i = 0; int nrow = 0; int ncol = 0; string header = ""; GetCotentInfo(ref nrow, ref ncol, ref header); ILArray <T> array = ILMath.zeros <T>(nrow, ncol); StreamReader sr = new StreamReader(_Filename); try { header = sr.ReadLine(); string line = ""; for (i = 0; i < nrow; i++) { line = sr.ReadLine(); var buf = TypeConverterEx.Split <T>(line); for (int j = 0; j < ncol; j++) { array.SetValue(buf[j], i, j); } } } catch (Exception ex) { ErrorMessage = ex.Message; } sr.Close(); return(array); }
private void TestQuickSortDesc() { try { ILArray <double> A = ILMath.counter(5, 4, 3); System.Diagnostics.Debug.Assert(!A.IsReference); ILArray <double> result = ILMath.sort(A, 1, true); ILArray <double> expect = A[":;3,2,1,0;:"]; if (!result.Equals(expect)) { throw new Exception("invalid values"); } // test scalar A = 3.0; result = ILMath.sort(A, 0, true); if (result != 3.0) { throw new Exception("invalid values: scalar"); } // test empty A = ILArray <double> .empty(); if (!ILMath.sort(A, 0, true).IsEmpty) { throw new Exception("invalid values: empty"); } Success(); } catch (Exception e) { Error(0, e.Message); } }
private void Plot2D(int selectedFuncId) { var range = 7000; float[][] points = _benchmark.GeneratePoints(range); ILArray <float> A = ILMath.zeros <float>(3, points.GetLength(0)); for (int i = 0; i < points.GetLength(0); i++) { A[0, i] = points[i][0]; A[1, i] = CallFunction(selectedFuncId, points[i]); } _scene = new ILScene(); _scene.Add(new ILPlotCube(twoDMode: true) { new ILPoints { Positions = ILMath.tosingle(A) } }); ilPanel1.Scene = _scene; ilPanel1.Refresh(); return; }
private void TestQuickSortLoop(int len, int rep) { try { m_stopwatch.Stop(); m_stopwatch.Reset(); for (int r = 0; r < rep; r++) { double[] p = ILMath.rand(1, len).m_data; m_stopwatch.Start(); ILQuickSort.QuickSortAscSolid_IT(p, 0, len - 1, 1); m_stopwatch.Stop(); if (!ILMath.IsSorted(p, false)) { throw new Exception("unsorted values detected (asc). Size: " + p.Length); } // descending ILQuickSort.QuickSortDescSolid_IT(p, 0, len - 1, 1); if (!ILMath.IsSorted(p, true)) { throw new Exception("unsorted values detected (desc). Size: " + p.Length); } } Success(" elapsed: " + m_stopwatch.ElapsedMilliseconds + " ms"); } catch (Exception e) { Error(0, e.Message); } }
/// <summary> /// update composite shape /// </summary> /// <param name="X">x coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param> /// <param name="Y">y coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param> /// <param name="Z">z coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param> /// <param name="mapping">Mapping of shapes, composes shapes out of vertices. Matrix having /// <see cref="ILNumerics.Drawing.Shapes.ILShape<T>.VerticesPerShape"/> rows. /// Every element in a column specifies the index of a vertex according to its position in X,Y,Z. /// The <see cref="ILNumerics.Drawing.Shapes.ILShape<T>.VerticesPerShape"/> elements in a column therefore /// compose a single shape. Vertices may get used arbitrary times (or not at all). All elements must be /// positive integer values in range 0...[<see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/>-1].</param> /// <remarks>All vertices of the shape are updated with the data specified in X,Y and Z. Neither the colors or any /// other data of vertices are changed. The shape is invalidated for reconfiguration at next redraw. </remarks> public void Update(ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray mapping) { if (!X.IsVector || !Y.IsVector || !Z.IsVector || X.Length != Y.Length || Y.Length != Z.Length) { throw new ILArgumentException("numeric vectors of same length expected for: X, Y and Z"); } if (mapping == null || mapping.IsEmpty || !mapping.IsMatrix || !mapping.IsNumeric || mapping.Dimensions[0] != VerticesPerShape) { throw new ILArgumentException("mapping must be a numeric matrix, " + VerticesPerShape.ToString() + " rows, each column specifies indices for the vertices of a single shape."); } if (mapping is ILArray <int> ) { m_shapeIndices = (mapping as ILArray <int>).C; } else { m_shapeIndices = ILMath.toint32(mapping); } ILArray <float> fX = ILMath.tosingle(X); ILArray <float> fY = ILMath.tosingle(Y); ILArray <float> fZ = ILMath.tosingle(Z); for (int i = 0; i < m_vertices.Length; i++) { m_vertices[i].XPosition = fX.GetValue(i); m_vertices[i].YPosition = fY.GetValue(i); m_vertices[i].ZPosition = fZ.GetValue(i); } Invalidate(); }
// the callback from naudio void waveInStream_DataAvailable(object sender, WaveInEventArgs e) { if (m_shutdown) { return; } using (ILScope.Enter()) { // prepare variables for requesting X values and the index of the maximum value ILArray <int> maxID = 1; // convert the recorded samples in computation module: ILArray <float> Y = Computation.GetMagnitudes(e.Buffer, e.BytesRecorded, m_fftlen, maxID); // update the line shape Line.Update(Y); // update the marker point ILArray <float> markerPoints = ILMath.zeros <float>(2, maxID.S[0]); markerPoints[0, ":"] = ILMath.tosingle(maxID); markerPoints[1, ":"] = Y[maxID]; Marker.Update(markerPoints); // on the first only run we zoom to content if (m_startup) { m_startup = false; ilPanel1.Scene.First <ILPlotCube>().Reset(); } // redraw the scene ilPanel1.Refresh(); } }
/// <summary> /// create composite shape /// </summary> /// <param name="panel">scene hosting the scene</param> /// <param name="numVertices">number of overall vertices for the shape</param> /// <param name="verticesPerShape">Number of vertices per shape</param> public ILCompositeShape(ILPanel panel, int numVertices, int verticesPerShape) : base(panel, numVertices, verticesPerShape) { Opacity = 255; m_shapeIndices = ILMath.toint32( ILMath.counter(0.0, 1.0, VerticesPerShape, numVertices / VerticesPerShape)); }
private void Test_isConj(ILArray <complex> A, ILArray <complex> conjA) { try { if (A.IsEmpty) { if (!conjA.IsEmpty) { throw new Exception("conj of empty array must be empty!"); } else { Success(); return; } } if (!A.Dimensions.IsSameSize(conjA.Dimensions)) { throw new Exception("dimensions must match!"); } if (ILMath.sumall(ILMath.real(A) != ILMath.real(conjA)) > 0.0) { throw new Exception("real parts must match!"); } if (ILMath.sumall(-ILMath.imag(A) != ILMath.imag(conjA)) > 0.0) { throw new Exception("imag parts must be the inverse of each other!"); } Success(); } catch (Exception exc) { Error(exc.Message); } }
public Bars AddBars(ILArray <double> barStart, ILArray <double> barEnd, ILArray <double> barPosition, ILArray <double> barThickness, BarType barType) { int n = barStart.Dimensions[0]; if (barThickness.IsScalar) { barThickness = ILMath.ones(n) * barThickness; } Bars bars = new Bars(this, barStart, barEnd, barPosition, barThickness, barType); barsList.Add(bars); foreach (Path rectangle in bars.Paths) { canvas.Children.Add(rectangle); IBoundableFromChild.Add((object)(rectangle), bars); } if (graphToCanvas.Matrix.M11 != 0) { ViewedRegion = GetCanvasChildrenBounds(); } else { ViewedRegion = bars.Bounds; } return(bars); }
public DataCube(int nvar, int ntime, int ncell, bool islazy = false) { _isLazy = islazy; _nvar = nvar; _ntime = ntime; _ncell = ncell; _size = new int[] { nvar, ntime, ncell }; _arrays = new ILArray <T> [nvar]; if (!islazy) { for (int i = 0; i < nvar; i++) { _arrays[i] = ILMath.zeros <T>(ntime, ncell); } DataCubeType = Data.DataCubeType.General; } else { DataCubeType = Data.DataCubeType.Varient; } Name = "default"; PopulateVariables(); InitFlags(Size[0], Size[1]); AllowTableEdit = false; TimeBrowsable = false; }
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 void forwBackwCheck1DAlongD(ILArray <float> A, ILArray <fcomplex> Result, int p) { try { ILArray <fcomplex> B = fft(A, p); //double errMult = 1/(A.Dimensions.NumberOfElements * Math.Pow(10,A.Dimensions.NumberOfDimensions)); float errMult = (float)Math.Pow(0.1f, A.Dimensions.NumberOfDimensions) / A.Dimensions.NumberOfElements; if (!A.IsScalar) { errMult /= (float)A.Dimensions[A.Dimensions.FirstNonSingleton()]; } if (sumall(abs(subtract(Result, B))) * errMult > (double)MachineParameterFloat.eps) { throw new Exception("invalid value"); } ILArray <float> ResultR = ifftsym(B, p); if (ILMath.sumall(ILMath.abs(ResultR - A)) * errMult > (double)ILMath.MachineParameterFloat.eps) { throw new Exception("invalid value"); } B = ifft(B, p); if (ILMath.sumall(ILMath.abs(ILMath.tofcomplex(A) - B)) * errMult > (double)ILMath.MachineParameterFloat.eps) { throw new Exception("invalid value"); } } catch (ILNumerics.Exceptions.ILArgumentException) { throw new Exception("unexpected exception was thrown -> error!"); } }
private void ilPanel1_Load(object sender, EventArgs e) { var inrows = 0; inrows = inrows + 1; tempX.Add(float.Parse(Gyrox, CultureInfo.InvariantCulture)); tempY.Add(float.Parse(Gyroy, CultureInfo.InvariantCulture)); tempZ.Add(float.Parse(Gyroz, CultureInfo.InvariantCulture)); ILArray <float> datasamples = ILMath.zeros <float>(3, (int)inrows); datasamples["0;:"] = tempX.ToArray(); datasamples["1;:"] = tempY.ToArray(); datasamples["2;:"] = tempZ.ToArray(); tempX.Clear(); tempY.Clear(); tempZ.Clear(); var scene = new ILScene { new ILPlotCube(twoDMode: false) { new ILPoints { Positions = datasamples, Color = Color.Blue, Size = 10 } } }; ilPanel1.Scene = scene; }
private double calcVarianceFunctionIL(double[] xi, double[] xj, ILArray <double> dispersion) { ILArray <double> xiIL = xi; ILArray <double> xjIL = xj; return((double)ILMath.multiply(ILMath.multiply(xiIL.T, dispersion), xjIL)); }
/// <summary> /// greater operator of <![CDATA[ILArray<>]]> with <![CDATA[ILArray<>]]> /// </summary> /// <param name="in1"><![CDATA[ILArray<>]]></param> /// <param name="in2"><![CDATA[ILArray<>]]></param> /// <returns>ILLogicalArray of same size than in1, with elements having 'true' values /// for all corresponding elements of in1 greater in2's elements, false if they are not. /// </returns> /// <remarks>Dimension of in1 and in2 must match. This operator is overloaded for /// all numeric types of <![CDATA[ILArray<>]]>. The type of in1 must be the same as the /// type of in2.</remarks> public static ILLogicalArray operator >(ILArray <BaseT> in1, ILArray <BaseT> in2) { if (false) { #region HYCALPER LOOPSTART GT } else if (in1 is /*!HC:inCls1*/ ILArray <double> && in2 is /*!HC:inCls2*/ ILArray <double> ) { return(ILMath.gt(in1 as /*!HC:inCls1*/ ILArray <double>, in2 as /*!HC:inCls2*/ ILArray <double>)); #endregion HYCALPER LOOPEND GT #region HYCALPER AUTO GENERATED CODE // DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !! } else if (in1 is ILArray <complex> && in2 is ILArray <complex> ) { return(ILMath.gt(in1 as ILArray <complex>, in2 as ILArray <complex>)); } else if (in1 is ILArray <byte> && in2 is ILArray <byte> ) { return(ILMath.gt(in1 as ILArray <byte>, in2 as ILArray <byte>)); #endregion HYCALPER AUTO GENERATED CODE } else { throw new ILArgumentTypeException("Operator '>' is not defined for ILArrays of type " + in1.GetType().Name + " and " + in2.GetType().Name); } }