public VantagePointTree( DistanceFunction <T> distanceFunction, List <T> items) : this(distanceFunction) { Build(items); }
public void HammingTest2() { var xs = new[] { 1.0, 1, 1, 1 }; var ys = new[] { -1.0, -1, -1, -1 }; DistanceFunction.Hamming(xs, ys).ShouldBe(4); }
public static BestWindow FindBestWindowType(DistanceFunction distance, KernelFunction kernel, DataSet dataSet, Double maxDistance, Boolean oneHot) { (Double maxMicro, Double maxMacro, Window bestWindow) = (Double.MinValue, Double.MinValue, null); for (Int32 i = 1; i < (Int32)(dataSet.Count / 2); i++) //Тут тоже надо шаманить от размера { CheckWindow(new Window(i)); } for (Double i = 0; i < maxDistance; i += 0.5) //Шаг надо менять от размера датасета { CheckWindow(new Window(i)); } void CheckWindow(Window window) { ConfusionMatrix confusion = dataSet.GetConfusionMatrix(distance, kernel, window, oneHot); (Double macro, Double micro) = (confusion.MicroF1Score(1), confusion.MacroF1Score(1)); if (micro > maxMicro && macro > maxMacro) { (maxMacro, maxMicro, bestWindow) = (macro, micro, window); } } Console.WriteLine(distance.Method.Name + " | " + kernel.Method.Name + " | " + bestWindow.IsFixed + " | Micro : " + maxMicro + " | Macro " + maxMacro); return(new BestWindow(bestWindow, maxMicro, maxMacro)); }
public void HammingTest4() { var xs = Enumerable.Repeat(1.0, 100).ToArray(); var ys = Enumerable.Repeat(0.0, 100).ToArray(); DistanceFunction.Hamming(xs, ys).ShouldBe(100); }
public void HammingTest1() { var xs = new[] { 0.0, 1, 2, 3 }; var ys = new[] { 0.0, 1, 1, 2 }; DistanceFunction.Hamming(xs, ys).ShouldBe(2); }
/// <summary> /// Comparer for ordering points based on their distances from a base point /// </summary> public TreeItemComparer( T baseItem, DistanceFunction <T> distanceFunction) { _baseItem = baseItem; _distanceFunction = distanceFunction; }
/// <summary> /// Creates the algorithm instance using selected distance function, similarity function and similarity function parameter. /// </summary> /// <param name="distanceFunction">Distance function selector.</param> /// <param name="similarityFunction">Similarity function selector.</param> /// <param name="similarityParameter">Parameter of the similarity function.</param> public PCTSignaturesSQFD( DistanceFunction distanceFunction = DistanceFunction.L2, SimilarityFunction similarityFunction = SimilarityFunction.Heuristic, float similarityParameter = 1.0f) { _ptr = XFeatures2DInvoke.cvePCTSignaturesSQFDCreate(distanceFunction, similarityFunction, similarityParameter, ref _sharedPtr); }
public void MinkowskiTest4() { var xs = Enumerable.Repeat(1.0, 100).ToArray(); var ys = Enumerable.Repeat(0.0, 100).ToArray(); DistanceFunction.Minkowski(xs, ys, 10).ShouldBe(1.58489, 0.00001); }
public void ManhattenTest3() { var xs = new[] { 1.0, 2, 3, 4, 5, 6, 7, 8, 9 }; DistanceFunction.Manhatten(xs, xs).ShouldBe(0); DistanceFunction.ManhattenFast(xs, xs).ShouldBe(0); }
public void MinkowskiTest1() { var xs = new[] { 0.0, 3, 4, 5 }; var ys = new[] { 7.0, 6, 3, -1 }; DistanceFunction.Minkowski(xs, ys, 5).ShouldBe(7.568, 0.0001); }
/// <summary> /// Sets the function applied to the number returned from the center of each cell.<br/> /// Can be used to create different shapes for your cells. /// </summary> /// <param name="distanceFunction">Distance function to use</param> public void SetDistanceFunction(DistanceFunction distanceFunction) { switch (distanceFunction) { case DistanceFunction.Euclidean: _generator.Set("DistanceFunction", "Euclidean"); break; case DistanceFunction.EuclideanSquared: _generator.Set("DistanceFunction", "EuclideanSquared"); break; case DistanceFunction.Manhattan: _generator.Set("DistanceFunction", "Manhattan"); break; case DistanceFunction.Hybrid: _generator.Set("DistanceFunction", "Hybrid"); break; case DistanceFunction.MaxAxis: _generator.Set("DistanceFunction", "MaxAxis"); break; default: throw new ArgumentOutOfRangeException(nameof(distanceFunction), distanceFunction, null); } }
RaymarchingResult Raymarching(Vector3 dir) { var dist = 0f; var len = 0f; var pos = transform.position + radius * dir; var loop = 0; for (loop = 0; loop < 10; ++loop) { dist = DistanceFunction.CalcDistance(pos); len += dist; pos += dir * dist; if (dist < MIN_DIST || len > MAX_DIST) { break; } } var result = new RaymarchingResult(); result.loop = loop; result.isBuried = DistanceFunction.CalcDistance(transform.position) < MIN_DIST; result.distance = dist; result.length = len; result.direction = dir; result.position = pos; result.normal = DistanceFunction.CalcNormal(pos); return(result); }
public ConfusionMatrix GetConfusionMatrix(DistanceFunction distance, KernelFunction kernel, Window window, Boolean oneHot) { Int32[,] matrix = new Int32[_classCount, _classCount]; for (Int32 i = 0; i < _dataSet.Length; i++) { Int32 predict; if (oneHot) { predict = OneHotLeaveOneOutStep(distance, kernel, window, i); } else { predict = (Int32)Math.Round(LeaveOneOutStep(distance, kernel, window, i)); } if (predict > _classCount) { predict = _classCount - 1; } Int32 actual = _dataSet[i].Label; matrix[actual, predict]++; } return(new ConfusionMatrix(matrix)); }
public void MinkowskiTest2() { var xs = new[] { 1.0, 2, 3, 4 }; var ys = new[] { -4.0, -5, -6, -7 }; DistanceFunction.Minkowski(xs, ys, 5).ShouldBe(11.91, 0.01); }
public void EuclideanTest3() { var xs = new[] { 1.0, 2, 3, 4, 5, 6, 7, 8, 9 }; DistanceFunction.Euclidean(xs, xs).ShouldBe(0); DistanceFunction.EuclideanFast(xs, xs).ShouldBe(0); }
private static IFunction MakeFunction(float modelScale) { var rand = new RandomGradientFunction { Interpolation = new QuinticInterpolation(), Normal = HashedRandomNormal.Arbitrary, }; var frac = new ScaleDomainToSphereFunction { Input = new FBMFractalFunction { BasisFunction = rand, Seed = 10, }, Radius = 1, }; var frac2 = new ScaleDomainToSphereFunction { Input = new FBMFractalFunction { BasisFunction = rand, Seed = 11, }, Radius = 1, }; var frac3 = new ScaleDomainToSphereFunction { Input = new FBMFractalFunction { BasisFunction = rand, Seed = 12, }, Radius = 1, }; var circle = new DistanceFunction { Reference = new Vector3(), }; var pertCircle = new TranslateDomainFunction { Input = circle, TranslationX = frac, TranslationY = frac2, TranslationZ = frac3, }; var rescale = new RescaleFunction { Input = pertCircle, K = -0.5f, B = 1, }; var scaleDomain = new ScaleDomainFunction { Input = rescale, Ratio = 2 / modelScale, }; return(scaleDomain); }
public void EuclideanTest1() { var xs = new[] { 2.0, -2.0 }; var ys = new[] { -1.0, 2.0 }; DistanceFunction.Euclidean(xs, ys).ShouldBe(5); DistanceFunction.EuclideanFast(xs, ys).ShouldBe(5); }
public WorleyNoise(int seed, float jitter, DistanceFunction distanceFunc = DistanceFunction.Euclidean, CombinationFunction combinationFunc = CombinationFunction.D1_D0) { Jitter = jitter; Distance = distanceFunc; Combination = combinationFunc; Perm = new NoiseUtil.PermutationTable(1024, 255, seed); }
public void EuclideanTest2() { var xs = new[] { 6.0, 5, 4, 3, 0, 2, 1, 0 }; var ys = new[] { 0.0, 0, 0, 0, -3, 0, 0, 0 }; DistanceFunction.Euclidean(xs, ys).ShouldBe(10); DistanceFunction.EuclideanFast(xs, ys).ShouldBe(10); }
public Entry( int x, int y, DistanceFunction distanceFunction ) { m_X = x; m_Y = y; if( distanceFunction == DistanceFunction.Geometric ) ApplyGeometricDistance(); else ApplyLinearDistance(); }
public void ManhattenTest4() { var xs = Enumerable.Repeat(1.0, 100).ToArray(); var ys = Enumerable.Repeat(0.0, 100).ToArray(); DistanceFunction.Manhatten(xs, ys).ShouldBe(100); DistanceFunction.ManhattenFast(xs, ys).ShouldBe(100); }
public void ManhattenTest2() { var xs = new[] { 6.0, 5, 4, 3, 0, 2, 1, 0 }; var ys = new[] { 0.0, 0, 0, 0, -3, 0, 0, 0 }; DistanceFunction.Manhatten(xs, ys).ShouldBe(24); DistanceFunction.ManhattenFast(xs, ys).ShouldBe(24); }
public void ManhattenTest1() { var xs = new[] { 2.0, -2 }; var ys = new[] { -1.0, 2 }; DistanceFunction.Manhatten(xs, ys).ShouldBe(7); DistanceFunction.ManhattenFast(xs, ys).ShouldBe(7); }
public void EuclideanTest4() { var xs = Enumerable.Repeat(1.0, 100).ToArray(); var ys = Enumerable.Repeat(0.0, 100).ToArray(); DistanceFunction.Euclidean(xs, ys).ShouldBe(10); DistanceFunction.EuclideanFast(xs, ys).ShouldBe(10); }
public void TestDistanceChangeEuclidean() { var cluster = new UMCClusterLight(); cluster.MassMonoisotopic = 500; cluster.Net = .5; cluster.Net = .5; cluster.DriftTime = 20; var euclid = new EuclideanDistanceMetric <UMCClusterLight>(); DistanceFunction <UMCClusterLight> func = euclid.EuclideanDistance; var deltaNet = .01; double deltaMassPPM = 1; double deltaDriftTime = 1; Console.WriteLine("Mass Diff, Mass Dist, Net, Net Dist, Drift, Drift Dist"); for (var i = 0; i < 50; i++) { var clusterD = new UMCClusterLight(); var clusterN = new UMCClusterLight(); var clusterM = new UMCClusterLight(); clusterM.DriftTime = cluster.DriftTime + deltaDriftTime; clusterM.Net = cluster.Net + deltaNet; clusterM.Net = cluster.Net + deltaNet; clusterM.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM * i); clusterN.DriftTime = cluster.DriftTime + deltaDriftTime; clusterN.Net = cluster.Net + (deltaNet * i); clusterN.Net = cluster.Net + (deltaNet * i); clusterN.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); clusterD.DriftTime = cluster.DriftTime + (deltaDriftTime * i); clusterD.Net = cluster.Net + deltaNet; clusterD.Net = cluster.Net + deltaNet; clusterD.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); var distM = func(cluster, clusterM); var distN = func(cluster, clusterN); var distD = func(cluster, clusterD); var output = string.Format("{0},{1},{2},{3},{4},{5}", deltaMassPPM * i, distM, deltaNet * i, distN, deltaDriftTime * i, distD); Console.WriteLine(output); } }
public Entry(int x, int y, DistanceFunction distanceFunction) { m_X = x; m_Y = y; if (distanceFunction == DistanceFunction.Geometric) { ApplyGeometricDistance(); } else { ApplyLinearDistance(); } }
/// <summary> /// 构造函数 /// </summary> /// <param name="root">根节点的值</param> /// <param name="distanceFunction">默认使用编辑距离</param> public BKTree(T root, DistanceFunction distanceFunction = null) { if (distanceFunction == null) { this.distanceFunction = this.LevenshteinDistance; } else { this.distanceFunction = distanceFunction; } rootNode = new Node <T>(root); length = 0; modCount = 0; }
private double GetAverageClusterDistance(U clusterI, U clusterJ, DistanceFunction <T> function) { double sum = 0; foreach (var featureI in clusterI.Features) { foreach (var featureJ in clusterJ.Features) { sum = function(featureI, featureJ); } } sum = sum / Convert.ToDouble(clusterI.Features.Count * clusterJ.Features.Count); return(sum); }
public WorleyNoise(int seed, float frequency, float perterbAmp, float cellularJitter, DistanceFunction distanceFunction, CellularReturnType cellularReturnType, Distance2EdgeBorder distance2EdgeBorder) { this.seed = seed; this.frequency = frequency; this.perterbAmp = perterbAmp; this.cellularJitter = cellularJitter; this.distanceFunction = distanceFunction; this.cellularReturnType = cellularReturnType; this.distance2EdgeBorder = distance2EdgeBorder; topologyUtil = new TopologyUtil().Construct(); cell_2D = new CELL_2D(); X_PRIME = 1619; Y_PRIME = 31337; }
public static float CellNoise(Vector3 position, float seed, DistanceFunction distanceFunction = DistanceFunction.EUCLIDIAN, CombineFunction combineFunction = CombineFunction.d0) { var gain = 1.0f; var value = 0.0f; var octaves = 4; var frequency = 2.0f; var amplitude = 0.5f; for (byte i = 0; i < octaves; i++) { value += Noise3D(new Vector3(position.x * gain * frequency, position.y * gain * frequency, position.z * gain * frequency), seed, distanceFunction, combineFunction) * amplitude / gain; gain *= 2f; } return(value); }
/// <summary> /// Evaluates the cross validation error for each fold. /// </summary> /// <param name="filePath">The training file path (after feature extraction).</param> /// <param name="learningParameters">The learning parameters.</param> /// <param name="nFolds">The number of folds.</param> /// <param name="distance">The distance function to evaluate the scores.</param> /// <returns>An array, each element containing the error over the fold.</returns> public double[] CrossValidationScore(string filePath, LearningParameters learningParameters, int nFolds, DistanceFunction distance) { double[] perFoldError = new double[nFolds]; int currentLine = 0; foreach (Tuple<WeightedPoint, List<string>> line in YieldLines(filePath, true, learningParameters)) { currentLine++; for (int i = 0; i < nFolds; i++) if (currentLine % nFolds == i) // predict over the i-th field perFoldError[i] += distance(line.Item1, PredictFromLine(_vectorsCV[i], line.Item2, learningParameters)); } for (int i = 0; i < nFolds; i++) perFoldError[i] = perFoldError[i] / currentLine * 5; return perFoldError; }
public VoronoiNoiseMatrix(int size, int seed, int octNum, float frq, float amp, CombinatorFunction combinatorFunction, DistanceFunction distanceFunction) : base( NAME, //Input new ParameterDefinition[] { }, //Output "x", size, 0, 255 ) { this.seed = seed; this.octNum = octNum; this.frq = frq; this.amp = amp; this.combinatorFunction = combinatorFunction; this.distanceFunction = distanceFunction; }
private float GetClosestPointParamOnSegmentIntern( DistanceFunction distFnc, float start, float end, float step ) { float minDistance = Mathf.Infinity; float minParam = 0f; for( float param = start; param <= end; param += step ) { float distance = distFnc( GetPositionOnSpline( param ) ); if( minDistance > distance ) { minDistance = distance; minParam = param; } } return minParam; }
private float GetClosestPointParamIntern( DistanceFunction distFnc, int iterations, float start, float end, float step ) { iterations = Mathf.Clamp( iterations, 0, 5 ); float minParam = GetClosestPointParamOnSegmentIntern( distFnc, start, end, step ); for( int i = 0; i < iterations; i++ ) { float searchOffset = Mathf.Pow( 10f, -(i+2f) ); start = Mathf.Clamp01( minParam-searchOffset ); end = Mathf.Clamp01( minParam+searchOffset ); step = searchOffset * .1f; minParam = GetClosestPointParamOnSegmentIntern( distFnc, start, end, step ); } return minParam; }
public static float Noise3D(Vector3 input, float seed, DistanceFunction distanceFunction = DistanceFunction.EUCLIDIAN, CombineFunction combineFunction = CombineFunction.d0) { uint lastRandom, numberFeaturePoints; Vector3 randomDiff = Vector3.zero; Vector3 featurePoint = Vector3.zero; int cubeX, cubeY, cubeZ; float[] distanceArray = new float[3]; for (int i = 0; i < distanceArray.Length; i++) distanceArray[i] = Mathf.Infinity; int evalCubeX = Mathf.FloorToInt(input.x); int evalCubeY = Mathf.FloorToInt(input.y); int evalCubeZ = Mathf.FloorToInt(input.z); for (int i = -1; i < 2; ++i) { for (int j = -1; j < 2; ++j) { for (int k = -1; k < 2; ++k) { cubeX = evalCubeX + i; cubeY = evalCubeY + j; cubeZ = evalCubeZ + k; lastRandom = lcgRandom(hash((uint)(cubeX + seed), (uint)(cubeY), (uint)(cubeZ))); numberFeaturePoints = 1; for (uint l = 0; l < numberFeaturePoints; ++l) { lastRandom = lcgRandom(lastRandom); randomDiff.x = (float)lastRandom / 0x100000000; lastRandom = lcgRandom(lastRandom); randomDiff.y = (float)lastRandom / 0x100000000; lastRandom = lcgRandom(lastRandom); randomDiff.z = (float)lastRandom / 0x100000000; featurePoint.x = randomDiff.x + (float)cubeX; featurePoint.y = randomDiff.y + (float)cubeY; featurePoint.z = randomDiff.z + (float)cubeZ; switch(distanceFunction) { case DistanceFunction.EUCLIDIAN: insert(distanceArray, EuclidianDistanceFunc3(input, featurePoint)); break; case DistanceFunction.MANHATTAN: insert(distanceArray, ManhattanDistanceFunc3(input, featurePoint)); break; case DistanceFunction.CHEBYSHEV: insert(distanceArray, ChebyshevDistanceFunc3(input, featurePoint)); break; } } } } } float combine = 0f; switch(combineFunction) { case CombineFunction.d0: combine = CombineFunc_D0(distanceArray); break; case CombineFunction.d1: combine = CombineFunc_D1_D0(distanceArray); break; case CombineFunction.d2: combine = CombineFunc_D2_D0(distanceArray); break; } return Mathf.Clamp(combine * 2f - 1f, -1f, 1f); }