SubtractFast() public method

Subtracts vectors x and y and stores the result to target.
public SubtractFast ( int x, int y, double target ) : void
x int
y int
target double
return void
Esempio n. 1
0
        /// <summary>
        /// Finds (dimension + 1) initial points.
        /// </summary>
        /// <param name="extremes"></param>
        /// <returns></returns>
        private List <VertexWrap> FindInitialPoints(List <VertexWrap> extremes)
        {
            List <VertexWrap> initialPoints = new List <VertexWrap>();// { extremes[0], extremes[1] };

            VertexWrap first = null, second = null;
            double     maxDist = 0;

            double[] temp = new double[Dimension];
            for (int i = 0; i < extremes.Count - 1; i++)
            {
                var a = extremes[i];
                for (int j = i + 1; j < extremes.Count; j++)
                {
                    var b = extremes[j];
                    MathHelper.SubtractFast(a.PositionData, b.PositionData, temp);
                    var dist = MathHelper.LengthSquared(temp);
                    if (dist > maxDist)
                    {
                        first   = a;
                        second  = b;
                        maxDist = dist;
                    }
                }
            }

            initialPoints.Add(first);
            initialPoints.Add(second);

            for (int i = 2; i <= Dimension; i++)
            {
                double     maximum  = 0.000001;
                VertexWrap maxPoint = null;
                for (int j = 0; j < extremes.Count; j++)
                {
                    var extreme = extremes[j];
                    if (initialPoints.Contains(extreme))
                    {
                        continue;
                    }

                    var val = GetSquaredDistanceSum(extreme, initialPoints);

                    if (val > maximum)
                    {
                        maximum  = val;
                        maxPoint = extreme;
                    }
                }
                if (maxPoint != null)
                {
                    initialPoints.Add(maxPoint);
                }
                else
                {
                    int vCount = InputVertices.Count;
                    for (int j = 0; j < vCount; j++)
                    {
                        var point = InputVertices[j];
                        if (initialPoints.Contains(point))
                        {
                            continue;
                        }

                        var val = GetSquaredDistanceSum(point, initialPoints);

                        if (val > maximum)
                        {
                            maximum  = val;
                            maxPoint = point;
                        }
                    }

                    if (maxPoint != null)
                    {
                        initialPoints.Add(maxPoint);
                    }
                    else
                    {
                        ThrowSingular();
                    }
                }
            }
            return(initialPoints);
        }
Esempio n. 2
0
        /// <summary>
        /// Finds (dimension + 1) initial points.
        /// </summary>
        /// <param name="extremes"></param>
        /// <returns></returns>
        private List <int> FindInitialPoints(List <int> extremes)
        {
            List <int> initialPoints = new List <int>();

            int    first = -1, second = -1;
            double maxDist = 0;

            double[] temp = new double[Dimension];
            for (int i = 0; i < extremes.Count - 1; i++)
            {
                var a = extremes[i];
                for (int j = i + 1; j < extremes.Count; j++)
                {
                    var b = extremes[j];
                    MathHelper.SubtractFast(a, b, temp);
                    var dist = MathHelper.LengthSquared(temp);
                    if (dist > maxDist)
                    {
                        first   = a;
                        second  = b;
                        maxDist = dist;
                    }
                }
            }

            initialPoints.Add(first);
            initialPoints.Add(second);

            for (int i = 2; i <= Dimension; i++)
            {
                double maximum  = double.NegativeInfinity;
                int    maxPoint = -1;
                for (int j = 0; j < extremes.Count; j++)
                {
                    var extreme = extremes[j];
                    if (initialPoints.Contains(extreme))
                    {
                        continue;
                    }

                    var val = GetSquaredDistanceSum(extreme, initialPoints);

                    if (val > maximum)
                    {
                        maximum  = val;
                        maxPoint = extreme;
                    }
                }

                if (maxPoint >= 0)
                {
                    initialPoints.Add(maxPoint);
                }
                else
                {
                    int vCount = Vertices.Length;
                    for (int j = 0; j < vCount; j++)
                    {
                        if (initialPoints.Contains(j))
                        {
                            continue;
                        }

                        var val = GetSquaredDistanceSum(j, initialPoints);

                        if (val > maximum)
                        {
                            maximum  = val;
                            maxPoint = j;
                        }
                    }

                    if (maxPoint >= 0)
                    {
                        initialPoints.Add(maxPoint);
                    }
                    else
                    {
                        ThrowSingular();
                    }
                }
            }
            return(initialPoints);
        }