def interpolation(self, d):

        from itertools import product
        import numpy
        from numpy import array, column_stack
        from dolo.numeric.interpolation.multilinear import multilinear_interpolation


        smin = array([0.0]*d)
        smax = array([1.0]*d)
        orders = numpy.array( [4,3,5,6,3], dtype=numpy.int )
        orders = orders[:d]


        grid = column_stack( [e for e in product(*[numpy.linspace(smin[i],smax[i],orders[i]) for i in range(d)])])

        finer_grid = column_stack( [e for e in product(*[numpy.linspace(0,1,10)]*d) ] )

        if d == 1:
            f = lambda g: numpy.row_stack([
                2*g[0,:]
            ])
        elif d == 2:
            f = lambda g: numpy.row_stack([
                g[0,:] * g[1,:],
            ])
        elif d == 3:
            f = lambda g: numpy.row_stack([
                (g[0,:] - g[1,:]) * g[2,:],
            ])
        elif d== 4:
            f = lambda g: numpy.row_stack([
                (g[3,:] - g[1,:]) * (g[2,:] - g[0,:])
            ])
#

        values = f( grid )

        finer_grid = numpy.ascontiguousarray(finer_grid)

        interpolated_values = multilinear_interpolation(smin, smax, orders, values, finer_grid)


        from dolo.numeric.interpolation.smolyak import SmolyakGrid

        sg = SmolyakGrid( smin, smax ,3)
        sg.set_values( f(sg.grid) )

        smol_values = sg(finer_grid)

        true_values = f(finer_grid)

        err_0 = abs(true_values - smol_values).max()
        err_1 = abs(true_values - interpolated_values).max()

        # both errors should be 0, because interpolated function is a 2d order polynomial
        assert_almost_equal(err_1,0)

        from dolo.numeric.interpolation.multilinear import MultilinearInterpolator
        mul_interp = MultilinearInterpolator(smin,smax,orders)
        mul_interp.set_values( f( mul_interp.grid) )
        interpolated_values_2 = mul_interp( finer_grid )

        err_3 = (abs(interpolated_values- interpolated_values_2))
        assert_almost_equal(err_3,0)
Example #2
0
    def interpolation(self, d):

        from itertools import product
        import numpy
        from numpy import array, column_stack
        from dolo.numeric.interpolation.multilinear import multilinear_interpolation

        smin = array([0.0] * d)
        smax = array([1.0] * d)
        orders = numpy.array([4, 3, 5, 6, 3], dtype=numpy.int)
        orders = orders[:d]

        grid = column_stack([
            e for e in product(*[
                numpy.linspace(smin[i], smax[i], orders[i]) for i in range(d)
            ])
        ])

        finer_grid = column_stack(
            [e for e in product(*[numpy.linspace(0, 1, 10)] * d)])

        if d == 1:
            f = lambda g: numpy.row_stack([2 * g[0, :]])
        elif d == 2:
            f = lambda g: numpy.row_stack([
                g[0, :] * g[1, :],
            ])
        elif d == 3:
            f = lambda g: numpy.row_stack([
                (g[0, :] - g[1, :]) * g[2, :],
            ])
        elif d == 4:
            f = lambda g: numpy.row_stack([(g[3, :] - g[1, :]) *
                                           (g[2, :] - g[0, :])])


#

        values = f(grid)

        finer_grid = numpy.ascontiguousarray(finer_grid)

        interpolated_values = multilinear_interpolation(
            smin, smax, orders, values, finer_grid)

        from dolo.numeric.interpolation.smolyak import SmolyakGrid

        sg = SmolyakGrid(smin, smax, 3)
        sg.set_values(f(sg.grid))

        smol_values = sg(finer_grid)

        true_values = f(finer_grid)

        err_0 = abs(true_values - smol_values).max()
        err_1 = abs(true_values - interpolated_values).max()

        # both errors should be 0, because interpolated function is a 2d order polynomial
        assert_almost_equal(err_1, 0)

        from dolo.numeric.interpolation.multilinear import MultilinearInterpolator
        mul_interp = MultilinearInterpolator(smin, smax, orders)
        mul_interp.set_values(f(mul_interp.grid))
        interpolated_values_2 = mul_interp(finer_grid)

        err_3 = (abs(interpolated_values - interpolated_values_2))
        assert_almost_equal(err_3, 0)
Example #3
0
    v = numpy.random.random((2,grid.shape[1]))
    points = numpy.random.random((d,N_fine_grid)) + np.array([1]*d)[:,None]

#    print(points)
    import time
    t = time.time()
    for i in range(10):
        out = multilinear_c(smin,smax,orders,v, points)
    s = time.time()

    print('New {}'.format(s-t))
    print(out.shape)

    import time
    from dolo.numeric.interpolation.multilinear import multilinear_interpolation

    t = time.time()
    for i in range(10):
        out_old = multilinear_interpolation( smin, smax, orders, v, points)
    print(out_old.shape)
    s = time.time()

    print('Old {}'.format(s-t))






    print(abs(out - out_old).max())