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);
}
