Imports System

Namespace MathEx.Interpolation

    '************************************************************************
    'Copyright (c) 2007, Sergey Bochkanov (ALGLIB project).
    '
    'Redistribution and use in source and binary forms, with or without
    'modification, are permitted provided that the following conditions are
    'met:
    '
    '- Redistributions of source code must retain the above copyright
    '  notice, this list of conditions and the following disclaimer.
    '
    '- Redistributions in binary form must reproduce the above copyright
    '  notice, this list of conditions and the following disclaimer listed
    '  in this license in the documentation and/or other materials
    '  provided with the distribution.
    '
    '- Neither the name of the copyright holders nor the names of its
    '  contributors may be used to endorse or promote products derived from
    '  this software without specific prior written permission.
    '
    'THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    '"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    'LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    'A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    'OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    'SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    'LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    'DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    'THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    '(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    'OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    '************************************************************************

    Public Class Interpolation

        Public Shared Function GetDampingFactor(current As Integer, count As Integer, min As Double, max As Double) As Double

            Dim df = (max - min) / count * current

            If df < min Then df = min
            If df > max Then df = max

            Return df

        End Function

        Public Shared Function Interpolate(x() As Double, y() As Double, xint As Double) As Double

            If x.Count = 1 Then
                Return xint / x(0) * y(0)
            ElseIf x.Count = 0 Then
                Return 0.0
            Else
                Dim w(x.Count) As Double
                ratinterpolation.buildfloaterhormannrationalinterpolant(x, x.Count, 0.5, w)
                Return polinterpolation.barycentricinterpolation(x, y, w, x.Count, xint)
            End If

        End Function

    End Class

    Public Class LinearInterpolation

        Public Shared Function Interpolate(x() As Double, y() As Double, xint As Double) As Double

            If x.Count = 1 Then
                Return xint / x(0) * y(0)
            ElseIf x.Count = 0 Then
                Return 0.0
            Else
                Return MathNet.Numerics.Interpolate.Linear(x, y).Interpolate(xint)
            End If

        End Function

    End Class

    Public Class LogLinearInterpolation

        Public Shared Function Interpolate(x() As Double, y() As Double, xint As Double) As Double

            If x.Count = 1 Then
                Return xint / x(0) * y(0)
            ElseIf x.Count = 0 Then
                Return 0.0
            Else
                Return MathNet.Numerics.Interpolate.LogLinear(x, y).Interpolate(xint)
            End If

        End Function

    End Class

    Public Class CubicSplineInterpolation

        Public Shared Function Interpolate(x() As Double, y() As Double, xint As Double) As Double

            If x.Count = 1 Then
                Return xint / x(0) * y(0)
            ElseIf x.Count = 0 Then
                Return 0.0
            Else
                Return MathNet.Numerics.Interpolate.CubicSpline(x, y).Interpolate(xint)
            End If

        End Function

    End Class

    Public Class polinterpolation

        '************************************************************************
        '    Interpolation using barycentric formula
        '
        '    F(t) = SUM(i=0,n-1,w[i]*f[i]/(t-x[i])) / SUM(i=0,n-1,w[i]/(t-x[i]))
        '
        '    Input parameters:
        '        X   -   interpolation nodes, array[0..N-1]
        '        F   -   function values, array[0..N-1]
        '        W   -   barycentric weights, array[0..N-1]
        '        N   -   nodes count, N>0
        '        T   -   interpolation point
        '        
        '    Result:
        '        barycentric interpolant F(t)
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Function barycentricinterpolation(x As Double(), f As Double(), w As Double(), n As Integer, t As Double) As Double
            Dim result As Double = 0
            Dim s1 As Double = 0
            Dim s2 As Double = 0
            Dim v As Double = 0
            Dim threshold As Double = 0
            Dim s As Double = 0
            Dim i As Integer = 0
            Dim j As Integer = 0

            System.Diagnostics.Debug.Assert(n > 0, "barycentricinterpolation: N<=0!")
            threshold = Math.Sqrt(AP.MathEx.MinRealNumber)

            '
            ' First, decide: should we use "safe" formula (guarded
            ' against overflow) or fast one?
            '
            j = 0
            s = t - x(0)
            For i = 1 To n - 1
                If Math.Abs(t - x(i)) < Math.Abs(s) Then
                    s = t - x(i)
                    j = i
                End If
            Next
            If s = 0 Then
                result = f(j)
                Return result
            End If
            If Math.Abs(s) > threshold Then

                '
                ' use fast formula
                '
                j = -1
                s = 1.0R
            End If

            '
            ' Calculate using safe or fast barycentric formula
            '
            s1 = 0
            s2 = 0
            For i = 0 To n - 1
                If i <> j Then
                    v = s * w(i) / (t - x(i))
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                Else
                    v = w(i)
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                End If
            Next
            result = s1 / s2
            Return result
        End Function


        '************************************************************************
        '    Polynomial interpolation on the equidistant nodes using barycentric
        '    formula. O(N) complexity.
        '
        '    Input parameters:
        '        A,B -   interpolation interval [A,B]
        '        F   -   function values, array[0..N-1].
        '                F[i] = F(A+(B-A)*i/(N-1))
        '        N   -   nodes count
        '        T   -   interpolation point
        '
        '    Result:
        '        the value of the interpolation polynomial F(t)
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Function equidistantpolynomialinterpolation(ByVal a As Double, ByVal b As Double, ByRef f As Double(), ByVal n As Integer, ByVal t As Double) As Double
            Dim result As Double = 0
            Dim s1 As Double = 0
            Dim s2 As Double = 0
            Dim v As Double = 0
            Dim threshold As Double = 0
            Dim s As Double = 0
            Dim i As Integer = 0
            Dim j As Integer = 0
            Dim w As Double = 0
            Dim x As Double = 0

            System.Diagnostics.Debug.Assert(n > 0, "barycentricinterpolation: N<=0!")
            threshold = Math.Sqrt(AP.MathEx.MinRealNumber)

            '
            ' Special case: N=1
            '
            If n = 1 Then
                result = f(0)
                Return result
            End If

            '
            ' First, decide: should we use "safe" formula (guarded
            ' against overflow) or fast one?
            '
            j = 0
            s = t - a
            For i = 1 To n - 1
                x = a + Convert.ToDouble((i)) / Convert.ToDouble((n - 1)) * (b - a)
                If Math.Abs(t - x) < Math.Abs(s) Then
                    s = t - x
                    j = i
                End If
            Next
            If s = 0 Then
                result = f(j)
                Return result
            End If
            If Math.Abs(s) > threshold Then

                '
                ' use fast formula
                '
                j = -1
                s = 1.0R
            End If

            '
            ' Calculate using safe or fast barycentric formula
            '
            s1 = 0
            s2 = 0
            w = 1.0R
            For i = 0 To n - 1
                If i <> j Then
                    v = s * w / (t - (a + Convert.ToDouble((i)) / Convert.ToDouble((n - 1)) * (b - a)))
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                Else
                    v = w
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                End If
                w = -(w * (n - 1 - i))
                w = w / (i + 1)
            Next
            result = s1 / s2
            Return result
        End Function


        '************************************************************************
        '    Polynomial interpolation on the Chebyshev nodes (first kind) using
        '    barycentric formula. O(N) complexity.
        '
        '    Input parameters:
        '        A,B -   interpolation interval [A,B]
        '        F   -   function values, array[0..N-1].
        '                F[i] = F(0.5*(B+A) + 0.5*(B-A)*Cos(PI*(2*i+1)/(2*n)))
        '        N   -   nodes count
        '        T   -   interpolation point
        '
        '    Result:
        '        the value of the interpolation polynomial F(t)
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Function chebyshev1interpolation(ByVal a As Double, ByVal b As Double, ByRef f As Double(), ByVal n As Integer, ByVal t As Double) As Double
            Dim result As Double = 0
            Dim s1 As Double = 0
            Dim s2 As Double = 0
            Dim v As Double = 0
            Dim threshold As Double = 0
            Dim s As Double = 0
            Dim i As Integer = 0
            Dim j As Integer = 0
            Dim a0 As Double = 0
            Dim delta As Double = 0
            Dim alpha As Double = 0
            Dim beta As Double = 0
            Dim ca As Double = 0
            Dim sa As Double = 0
            Dim tempc As Double = 0
            Dim temps As Double = 0
            Dim x As Double = 0
            Dim w As Double = 0
            Dim p1 As Double = 0

            System.Diagnostics.Debug.Assert(n > 0, "Chebyshev1Interpolation: N<=0!")
            threshold = Math.Sqrt(AP.MathEx.MinRealNumber)
            t = (t - 0.5 * (a + b)) / (0.5 * (b - a))

            '
            ' Prepare information for the recurrence formula
            ' used to calculate sin(pi*(2j+1)/(2n+2)) and
            ' cos(pi*(2j+1)/(2n+2)):
            '
            ' A0    = pi/(2n+2)
            ' Delta = pi/(n+1)
            ' Alpha = 2 sin^2 (Delta/2)
            ' Beta  = sin(Delta)
            '
            ' so that sin(..) = sin(A0+j*delta) and cos(..) = cos(A0+j*delta).
            ' Then we use
            '
            ' sin(x+delta) = sin(x) - (alpha*sin(x) - beta*cos(x))
            ' cos(x+delta) = cos(x) - (alpha*cos(x) - beta*sin(x))
            '
            ' to repeatedly calculate sin(..) and cos(..).
            '
            a0 = Math.PI / (2 * (n - 1) + 2)
            delta = 2 * Math.PI / (2 * (n - 1) + 2)
            alpha = 2 * AP.MathEx.Sqr(Math.Sin(delta / 2))
            beta = Math.Sin(delta)

            '
            ' First, decide: should we use "safe" formula (guarded
            ' against overflow) or fast one?
            '
            ca = Math.Cos(a0)
            sa = Math.Sin(a0)
            j = 0
            x = ca
            s = t - x
            For i = 1 To n - 1

                '
                ' Next X[i]
                '
                temps = sa - (alpha * sa - beta * ca)
                tempc = ca - (alpha * ca + beta * sa)
                sa = temps
                ca = tempc
                x = ca

                '
                ' Use X[i]
                '
                If Math.Abs(t - x) < Math.Abs(s) Then
                    s = t - x
                    j = i
                End If
            Next
            If s = 0 Then
                result = f(j)
                Return result
            End If
            If Math.Abs(s) > threshold Then

                '
                ' use fast formula
                '
                j = -1
                s = 1.0R
            End If

            '
            ' Calculate using safe or fast barycentric formula
            '
            s1 = 0
            s2 = 0
            ca = Math.Cos(a0)
            sa = Math.Sin(a0)
            p1 = 1.0R
            For i = 0 To n - 1

                '
                ' Calculate X[i], W[i]
                '
                x = ca
                w = p1 * sa

                '
                ' Proceed
                '
                If i <> j Then
                    v = s * w / (t - x)
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                Else
                    v = w
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                End If

                '
                ' Next CA, SA, P1
                '
                temps = sa - (alpha * sa - beta * ca)
                tempc = ca - (alpha * ca + beta * sa)
                sa = temps
                ca = tempc
                p1 = -p1
            Next
            result = s1 / s2
            Return result
        End Function


        '************************************************************************
        '    Polynomial interpolation on the Chebyshev nodes (second kind) using
        '    barycentric formula. O(N) complexity.
        '
        '    Input parameters:
        '        A,B -   interpolation interval [A,B]
        '        F   -   function values, array[0..N-1].
        '                F[i] = F(0.5*(B+A) + 0.5*(B-A)*Cos(PI*i/(n-1)))
        '        N   -   nodes count
        '        T   -   interpolation point
        '
        '    Result:
        '        the value of the interpolation polynomial F(t)
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Function chebyshev2interpolation(ByVal a As Double, ByVal b As Double, ByRef f As Double(), ByVal n As Integer, ByVal t As Double) As Double
            Dim result As Double = 0
            Dim s1 As Double = 0
            Dim s2 As Double = 0
            Dim v As Double = 0
            Dim threshold As Double = 0
            Dim s As Double = 0
            Dim i As Integer = 0
            Dim j As Integer = 0
            Dim a0 As Double = 0
            Dim delta As Double = 0
            Dim alpha As Double = 0
            Dim beta As Double = 0
            Dim ca As Double = 0
            Dim sa As Double = 0
            Dim tempc As Double = 0
            Dim temps As Double = 0
            Dim x As Double = 0
            Dim w As Double = 0
            Dim p1 As Double = 0

            System.Diagnostics.Debug.Assert(n > 1, "Chebyshev2Interpolation: N<=1!")
            threshold = Math.Sqrt(AP.MathEx.MinRealNumber)
            t = (t - 0.5 * (a + b)) / (0.5 * (b - a))

            '
            ' Prepare information for the recurrence formula
            ' used to calculate sin(pi*i/n) and
            ' cos(pi*i/n):
            '
            ' A0    = 0
            ' Delta = pi/n
            ' Alpha = 2 sin^2 (Delta/2)
            ' Beta  = sin(Delta)
            '
            ' so that sin(..) = sin(A0+j*delta) and cos(..) = cos(A0+j*delta).
            ' Then we use
            '
            ' sin(x+delta) = sin(x) - (alpha*sin(x) - beta*cos(x))
            ' cos(x+delta) = cos(x) - (alpha*cos(x) - beta*sin(x))
            '
            ' to repeatedly calculate sin(..) and cos(..).
            '
            a0 = 0.0R
            delta = Math.PI / (n - 1)
            alpha = 2 * AP.MathEx.Sqr(Math.Sin(delta / 2))
            beta = Math.Sin(delta)

            '
            ' First, decide: should we use "safe" formula (guarded
            ' against overflow) or fast one?
            '
            ca = Math.Cos(a0)
            sa = Math.Sin(a0)
            j = 0
            x = ca
            s = t - x
            For i = 1 To n - 1

                '
                ' Next X[i]
                '
                temps = sa - (alpha * sa - beta * ca)
                tempc = ca - (alpha * ca + beta * sa)
                sa = temps
                ca = tempc
                x = ca

                '
                ' Use X[i]
                '
                If Math.Abs(t - x) < Math.Abs(s) Then
                    s = t - x
                    j = i
                End If
            Next
            If s = 0 Then
                result = f(j)
                Return result
            End If
            If Math.Abs(s) > threshold Then

                '
                ' use fast formula
                '
                j = -1
                s = 1.0R
            End If

            '
            ' Calculate using safe or fast barycentric formula
            '
            s1 = 0
            s2 = 0
            ca = Math.Cos(a0)
            sa = Math.Sin(a0)
            p1 = 1.0R
            For i = 0 To n - 1

                '
                ' Calculate X[i], W[i]
                '
                x = ca
                If i = 0 Or i = n - 1 Then
                    w = 0.5 * p1
                Else
                    w = 1.0R * p1
                End If

                '
                ' Proceed
                '
                If i <> j Then
                    v = s * w / (t - x)
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                Else
                    v = w
                    s1 = s1 + v * f(i)
                    s2 = s2 + v
                End If

                '
                ' Next CA, SA, P1
                '
                temps = sa - (alpha * sa - beta * ca)
                tempc = ca - (alpha * ca + beta * sa)
                sa = temps
                ca = tempc
                p1 = -p1
            Next
            result = s1 / s2
            Return result
        End Function


        '************************************************************************
        '    Polynomial interpolation on the arbitrary nodes using Neville's algorithm.
        '    O(N^2) complexity.
        '
        '    Input parameters:
        '        X   -   interpolation nodes, array[0..N-1].
        '        F   -   function values, array[0..N-1].
        '        N   -   nodes count
        '        T   -   interpolation point
        '
        '    Result:
        '        the value of the interpolation polynomial F(t)
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Function nevilleinterpolation(ByRef x As Double(), ByVal f As Double(), ByVal n As Integer, ByVal t As Double) As Double
            Dim result As Double = 0
            Dim m As Integer = 0
            Dim i As Integer = 0

            f = DirectCast(f.Clone(), Double())

            n = n - 1
            For m = 1 To n
                For i = 0 To n - m
                    f(i) = ((t - x(i + m)) * f(i) + (x(i) - t) * f(i + 1)) / (x(i) - x(i + m))
                Next
            Next
            result = f(0)
            Return result
        End Function


        '************************************************************************
        '    Polynomial interpolation on the arbitrary nodes using Neville's algorithm.
        '    O(N^2) complexity. Subroutine  returns  the  value  of  the  interpolation
        '    polynomial, the first and the second derivative.
        '
        '    Input parameters:
        '        X   -   interpolation nodes, array[0..N-1].
        '        F   -   function values, array[0..N-1].
        '        N   -   nodes count
        '        T   -   interpolation point
        '
        '    Output parameters:
        '        P   -   the value of the interpolation polynomial F(t)
        '        DP  -   the first derivative of the interpolation polynomial dF(t)/dt
        '        D2P -   the second derivative of the interpolation polynomial d2F(t)/dt2
        '
        '      -- ALGLIB --
        '         Copyright 28.05.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Sub nevilledifferentiation(ByRef x As Double(), ByVal f As Double(), ByVal n As Integer, ByVal t As Double, ByRef p As Double, ByRef dp As Double, _
         ByRef d2p As Double)
            Dim m As Integer = 0
            Dim i As Integer = 0
            Dim df As Double() = New Double(-1) {}
            Dim d2f As Double() = New Double(-1) {}

            f = DirectCast(f.Clone(), Double())

            n = n - 1
            df = New Double(n) {}
            d2f = New Double(n) {}
            For i = 0 To n
                d2f(i) = 0
                df(i) = 0
            Next
            For m = 1 To n
                For i = 0 To n - m
                    d2f(i) = ((t - x(i + m)) * d2f(i) + (x(i) - t) * d2f(i + 1) + 2 * df(i) - 2 * df(i + 1)) / (x(i) - x(i + m))
                    df(i) = ((t - x(i + m)) * df(i) + f(i) + (x(i) - t) * df(i + 1) - f(i + 1)) / (x(i) - x(i + m))
                    f(i) = ((t - x(i + m)) * f(i) + (x(i) - t) * f(i + 1)) / (x(i) - x(i + m))
                Next
            Next
            p = f(0)
            dp = df(0)
            d2p = d2f(0)
        End Sub


        '************************************************************************
        '    Obsolete algorithm, replaced by NevilleInterpolation.
        '    ************************************************************************

        Public Shared Function lagrangeinterpolate(ByVal n As Integer, ByRef x As Double(), ByVal f As Double(), ByVal t As Double) As Double
            Dim result As Double = 0

            f = DirectCast(f.Clone(), Double())

            result = nevilleinterpolation(x, f, n, t)
            Return result
        End Function


        '************************************************************************
        '    Obsolete algorithm, replaced by NevilleInterpolationWithDerivative
        '    ************************************************************************

        Public Shared Sub lagrangederivative(ByVal n As Integer, ByRef x As Double(), ByVal f As Double(), ByVal t As Double, ByRef p As Double, ByRef dp As Double)
            Dim d2p As Double = 0

            f = DirectCast(f.Clone(), Double())

            nevilledifferentiation(x, f, n, t, p, dp, d2p)

        End Sub
    End Class

    '************************************************************************
    'Copyright (c) 2007, Sergey Bochkanov (ALGLIB project).
    '
    'Redistribution and use in source and binary forms, with or without
    'modification, are permitted provided that the following conditions are
    'met:
    '
    '- Redistributions of source code must retain the above copyright
    '  notice, this list of conditions and the following disclaimer.
    '
    '- Redistributions in binary form must reproduce the above copyright
    '  notice, this list of conditions and the following disclaimer listed
    '  in this license in the documentation and/or other materials
    '  provided with the distribution.
    '
    '- Neither the name of the copyright holders nor the names of its
    '  contributors may be used to endorse or promote products derived from
    '  this software without specific prior written permission.
    '
    'THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    '"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    'LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    'A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    'OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    'SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    'LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    'DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    'THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    '(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    'OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    '************************************************************************

    Public Class ratinterpolation

        '************************************************************************
        '    Rational barycentric interpolation without poles
        '
        '    The subroutine constructs the rational interpolating function without real
        '    poles. It should be noted that the barycentric weights of the  interpolant
        '    constructed are independent of the values of the given function.
        '
        '    Input parameters:
        '        X   -   interpolation nodes, array[0..N-1].
        '        N   -   number of nodes, N>0.
        '        D   -   order of the interpolation scheme, 0 <= D <= N-1.
        '
        '    Output parameters:
        '        W   -   array of the barycentric weights which  can  be  used  in  the
        '                BarycentriConvert.ToInt32erpolate subroutine. Array[0..N-1]
        '
        '    Note:
        '        this algorithm always succeeds and calculates the weights  with  close
        '        to machine precision.
        '
        '      -- ALGLIB PROJECT --
        '         Copyright 17.06.2007 by Bochkanov Sergey
        '    ************************************************************************

        Public Shared Sub buildfloaterhormannrationalinterpolant(ByVal x As Double(), ByVal n As Integer, ByVal d As Integer, ByRef w As Double())
            Dim s0 As Double = 0
            Dim s As Double = 0
            Dim v As Double = 0
            Dim i As Integer = 0
            Dim j As Integer = 0
            Dim k As Integer = 0
            Dim perm As Integer() = New Integer(-1) {}
            Dim wtemp As Double() = New Double(-1) {}
            Dim i_ As Integer = 0

            x = DirectCast(x.Clone(), Double())

            System.Diagnostics.Debug.Assert(n > 0, "BuildRationalInterpolantWithoutPoles: N<=0!")
            System.Diagnostics.Debug.Assert(d >= 0 And d <= n, "BuildRationalInterpolantWithoutPoles: incorrect D!")

            '
            ' Prepare
            '
            w = New Double(n - 1) {}
            s0 = 1
            For k = 1 To d
                s0 = -s0
            Next
            perm = New Integer(n - 1) {}
            For i = 0 To n - 1
                perm(i) = i
            Next
            For i = 0 To n - 2
                For j = i + 1 To n - 1
                    If x(j) < x(i) Then
                        s = x(i)
                        x(i) = x(j)
                        x(j) = s
                        k = perm(i)
                        perm(i) = perm(j)
                        perm(j) = k
                    End If
                Next
            Next

            '
            ' Calculate Wk
            '
            For k = 0 To n - 1

                '
                ' Wk
                '
                s = 0
                For i = Math.Max(k - d, 0) To Math.Min(k, n - 1 - d)
                    v = 1
                    For j = i To i + d
                        If j <> k Then
                            v = v / Math.Abs(x(k) - x(j))
                        End If
                    Next
                    s = s + v
                Next
                w(k) = s0 * s

                '
                ' Next S0
                '
                s0 = -s0
            Next

            '
            ' Reorder W
            '
            wtemp = New Double(n - 1) {}
            For i_ = 0 To n - 1
                wtemp(i_) = w(i_)
            Next
            For i = 0 To n - 1
                w(perm(i)) = wtemp(i)
            Next
        End Sub
    End Class

End Namespace