コード例 #1
0
ファイル: bubble.py プロジェクト: evyak/nanobubbles
 def h_constraint_der_zero(grid_points):
     """
     Boundary condition h'(0) = 0.
     """
     h_coef = grid_points[N_COEF_U:]
     h = Chebyshev(h_coef, domain=[0, radius])
     return h.deriv(m=1)(0.0)
コード例 #2
0
ファイル: lsq_problems.py プロジェクト: ev-br/lsq-benchmarks
    def __init__(self, n):
        self.x0 = (1 + np.arange(n)) / (n + 1)
        specs = []
        super(ChebyshevQuadrature, self).__init__(n, n, specs)

        cp = Chebyshev(1)
        self.T_all = [cp.basis(i + 1, domain=[0.0, 1.0]) for i in range(n)]
コード例 #3
0
ファイル: lsq_problems.py プロジェクト: RnD4RT/bounded-lsq
    def __init__(self, n):
        self.x0 = (1 + np.arange(n)) / (n + 1)
        specs = []
        super(ChebyshevQuadrature, self).__init__(n, n, specs)

        cp = Chebyshev(1)
        self.T_all = [cp.basis(i + 1, domain=[0.0, 1.0]) for i in range(n)]
コード例 #4
0
 def background(self, two_theta, intensities):
     n_deg = 5
     spline = Chebyshev(coef=np.ones((5,)))
     red_two_theta, red_intensities = self.remove_peaks(
         two_theta, self.smooth_data(intensities))
     # Fit the background using the reduced dataset
     spline = spline.fit(red_two_theta, red_intensities, n_deg)
     # Return the predicted background
     background = np.array(spline(two_theta))
     return background
コード例 #5
0
    def PolyDiff(self, u, x):
        """Differentiate data with polynomial interpolation.

        This method takes a collection of points of size (2*self.cheb_width),
        fits a Chebychev polynomial to the collection of points, and computes
        the derivative at the central point. The derivatives are collated and
        returned to the calling functions as a NumPy array.

        Keyword arguments:
        u -- values of some function
        x -- corresponding x-coordinates where u is evaluated

        Note: This throws out the data close to the edges since the polynomial
        derivative only works well when we're looking at the middle of the
        points fit.
        """
        u = u.flatten()
        x = x.flatten()

        n = len(x)

        # Initialize a numpy array for storing the derivative values
        du = np.zeros((n - 2 * self.cheb_width, self.diff_order))

        # Loop for fitting Cheb polynomials to each point
        for j in range(self.cheb_width, n - self.cheb_width):
            # Select the points on which to fit polynomial
            points = np.arange(j - self.cheb_width, j + self.cheb_width)
            # Fit the polynomial
            poly = Cheb.fit(x[points], u[points], self.cheb_degree)
            # Take derivatives
            for d in range(1, self.diff_order + 1):
                du[j - self.cheb_width, d - 1] = poly.deriv(m=d)(x[j])

        return du
コード例 #6
0
    def polynomials(self) -> List[List[float]]:
        """The polynomials for the piecewise approximation.

                Returns:
                    The polynomials for the piecewise approximation.
        """
        if self.num_state_qubits is None:
            return [[]]

        # note this must be the private attribute since we handle missing breakpoints at
        # 0 and 2 ^ num_qubits here (e.g. if the function we approximate is not defined at 0
        # and the user takes that into account we just add an identity)
        num_intervals = len(self._breakpoints)

        # Calculate the polynomials
        polynomials = []
        for i in range(0, num_intervals - 1):
            # Calculate the polynomial approximating the function on the current interval
            poly = Chebyshev.interpolate(self._f_x, self._degree,
                                         domain=[self._breakpoints[i],
                                                 self._breakpoints[i + 1]])
            # Convert polynomial to the standard basis and rescale it for the rotation gates
            poly = 2 * poly.convert(kind=np.polynomial.Polynomial).coef
            # Convert to list and append
            polynomials.append(poly.tolist())

        # If the last breakpoint is < 2 ** num_qubits, add the identity polynomial
        if self._breakpoints[-1] < 2 ** self.num_state_qubits:
            polynomials = polynomials + [[2 * np.arcsin(1)]]

        # If the first breakpoint is > 0, add the identity polynomial
        if self._breakpoints[0] > 0:
            polynomials = [[2 * np.arcsin(1)]] + polynomials

        return polynomials
コード例 #7
0
ファイル: bubble.py プロジェクト: evyak/nanobubbles
 def u_constraint_zero(grid_points):
     """
     Boundary condition u(0) = 0.
     """
     u_coef = grid_points[:N_COEF_U]
     u = Chebyshev(u_coef, domain=[0, radius])
     return u(0.0)
コード例 #8
0
def interpolate_cheb_from_col(cheb_column, bands, wave):
    bluest = np.min(bands)  #effective wavelength of bluest filter
    reddest = np.max(bands)  #effective wavelength of reddest filter
    if len(cheb_column) != len(wave):
        warnings.warn(
            "wave must be an array with the same number of elements as cheb_column"
        )
    else:
        funcs = {
            n: Chebyshev(cheb_column[n], domain=[bluest, reddest])
            for n in range(len(cheb_column))
        }

        polynom = np.zeros(len(cheb_column))
        for i in range(len(cheb_column)):
            if cheb_column[i][0] != -99:
                polynom[i] = funcs[i](wave[i])
                if wave[i] >= reddest or wave[i] <= bluest:
                    warnings.warn(
                        "The wavelength at which you're interpolating the Chebyshev polynomial for index:"
                        + str(i) +
                        " is outside the wavelength range of the used bands")
            else:
                polynom[i] = -99

    return polynom
コード例 #9
0
ファイル: bubble.py プロジェクト: evyak/nanobubbles
 def h_constraint(grid_points):
     """
     Boundary condition h(r) = 0.
     """
     h_coef = grid_points[N_COEF_U:]
     h = Chebyshev(h_coef, domain=[0, radius])    
     return h(radius)
コード例 #10
0
 def _setup_approximants(self):
     return [
         Chebyshev.interpolate(self.function,
                               self.degree,
                               domain=window,
                               *self.args) for window in self._windows
     ]
コード例 #11
0
ファイル: hw6.py プロジェクト: shawsa/m565
def cheb_series(x):
    sum = 0
    alpha = np.sqrt(2) - 1
    coef = np.zeros(11 * 2 + 1)
    for i in range(11):
        coef[2 * i + 1] = 1
        sum += (-1)**i / (2 * i + 1) * alpha**(2 * i + 1) * Chebyshev(coef)(x)
        coef[2 * i + 1] = 0
    return 2 * sum
コード例 #12
0
    def get_mode_cheb_coeffs(self, mode_index, cheb_order):
        """
        Cheb coeffs of a mode.
        The projection process is performed on [0,1]^dim.
        """

        import scipy.special as sps

        cheby_nodes, _, cheby_weights = \
            sps.chebyt(cheb_order).weights.T  # pylint: disable=E1136,E0633
        window = [0, 1]

        cheby_nodes = cheby_nodes * (window[1] -
                                     window[0]) / 2 + np.mean(window)
        cheby_weights = cheby_weights * (window[1] - window[0]) / 2

        mode = self.get_template_mode(mode_index)
        grid = np.meshgrid(*[cheby_nodes for d in range(self.dim)],
                           indexing='ij')
        mvals = mode(*grid)

        from numpy.polynomial.chebyshev import Chebyshev

        coef_scale = 2 * np.ones(cheb_order) / cheb_order
        coef_scale[0] /= 2
        basis_1d = np.array([
            Chebyshev(coef=_orthonormal(cheb_order, i),
                      domain=window)(cheby_nodes) for i in range(cheb_order)
        ])

        from itertools import product

        if self.dim == 1:
            basis_set = basis_1d

        elif self.dim == 2:
            basis_set = np.array([
                b1.reshape([cheb_order, 1]) * b2.reshape([1, cheb_order])
                for b1, b2 in product(*[basis_1d for d in range(self.dim)])
            ])

        elif self.dim == 3:
            basis_set = np.array([
                b1.reshape([cheb_order, 1, 1]) *
                b2.reshape([1, cheb_order, 1]) * b3.reshape([1, 1, cheb_order])
                for b1, b2, b3 in product(*[basis_1d for d in range(self.dim)])
            ])

        mode_cheb_coeffs = np.array([
            np.sum(mvals * basis) for basis in basis_set
        ]) * _self_tp(coef_scale, self.dim).reshape(-1)

        # purge small coeffs whose magnitude are less than 8 times machine epsilon
        mode_cheb_coeffs[np.abs(mode_cheb_coeffs) < 8 *
                         np.finfo(mode_cheb_coeffs.dtype).eps] = 0

        return mode_cheb_coeffs
コード例 #13
0
    def polynomials(self) -> List[List[float]]:
        """The polynomials for the piecewise approximation.

        Returns:
            The polynomials for the piecewise approximation.

        Raises:
            TypeError: If the input function is not in the correct format.
        """
        if self.num_state_qubits is None:
            return [[]]

        # note this must be the private attribute since we handle missing breakpoints at
        # 0 and 2 ^ num_qubits here (e.g. if the function we approximate is not defined at 0
        # and the user takes that into account we just add an identity)
        breakpoints = self._breakpoints
        # Need to take into account the case in which no breakpoints were provided in first place
        if breakpoints == [0]:
            breakpoints = [0, 2**self.num_state_qubits]

        num_intervals = len(breakpoints)

        # Calculate the polynomials
        polynomials = []
        for i in range(0, num_intervals - 1):
            # Calculate the polynomial approximating the function on the current interval
            try:
                # If the function is constant don't call Chebyshev (not necessary and gives errors)
                if isinstance(self.f_x, (float, int)):
                    # Append directly to list of polynomials
                    polynomials.append([self.f_x])
                else:
                    poly = Chebyshev.interpolate(
                        self.f_x, self.degree, domain=[breakpoints[i], breakpoints[i + 1]]
                    )
                    # Convert polynomial to the standard basis and rescale it for the rotation gates
                    poly = 2 * poly.convert(kind=np.polynomial.Polynomial).coef
                    # Convert to list and append
                    polynomials.append(poly.tolist())
            except ValueError as err:
                raise TypeError(
                    " <lambda>() missing 1 required positional argument: '"
                    + self.f_x.__code__.co_varnames[0]
                    + "'."
                    + " Constant functions should be specified as 'f_x = constant'."
                ) from err

        # If the last breakpoint is < 2 ** num_qubits, add the identity polynomial
        if breakpoints[-1] < 2**self.num_state_qubits:
            polynomials = polynomials + [[2 * np.arcsin(1)]]

        # If the first breakpoint is > 0, add the identity polynomial
        if breakpoints[0] > 0:
            polynomials = [[2 * np.arcsin(1)]] + polynomials

        return polynomials
コード例 #14
0
ファイル: bubble.py プロジェクト: evyak/nanobubbles
def get_volume_from_h_coefs(h, radius):
    """
    Returns volum of the bubble.
    h is Chebyshev polynomial coefficients for shape.
    radius is radius in A.
    """                    
    r = Chebyshev([radius/2, radius/2], domain=[0, radius])   
    pol_to_integrate = h * r
    return 2.0 * np.pi * (pol_to_integrate.integ()(radius) \
                          - pol_to_integrate.integ()(0.0))
コード例 #15
0
def chebyshev(coefs, time, domain):
    """Evaluate a Chebyshev Polynomial.

    Args:
        coefs (list, np.array): Coefficients defining the polynomial
        time (int, float): Time where to evaluate the polynomial
        domain (list, tuple): Domain (or time interval) for which the polynomial is defined: [left, right]
    Reference: Appendix A in the MSG Level 1.5 Image Data Format Description.

    """
    return Chebyshev(coefs, domain=domain)(time) - 0.5 * coefs[0]
コード例 #16
0
 def refine_background(self, scattering_lengths, intensities, s=None, k=4):
     
     """Fit a univariate spline to the background data.
     
     Arguments
     ---------
     - scattering_lengths : Array of scattering vector lengths, q.
     
     - intensities : Array of intensity values at each q position
     
     - s : Smoothing factor passed to the spline. Default is
         the variance of the background.
     
     - k : Degree of the spline (default quartic spline).
     """
     # Remove pre-indexed peaks for background fitting
     phase_list = self.phases + self.background_phases
     q, I = scattering_lengths, intensities
     for phase in phase_list:
         for reflection in phase.reflection_list:
             q, I = remove_peak_from_df(x=q, y=I, xrange=reflection.qrange)
     # Get an estimate for s from the non-peak data
     if s is None:
         s = np.std(I)
     # Smoothing for background fitting
     smoothI = savgol_filter(I, window_length=15, polyorder=5)
     # Determine a background line from the noise without peaks
     # self.spline = UnivariateSpline(
     #     x=q,
     #     y=I,
     #     s=s / 25,
     #     k=k,
     # )
     self.spline = Chebyshev(coef=np.ones((20,)))
     self.spline = self.spline.fit(q, smoothI, 10)
     # background = self.spline.cast(scattering_lengths)
     # self.spline = splrep(q, I)
     # Extrapolate the background for the whole pattern
     # background = self.spline(scattering_lengths)
     background = self.spline(scattering_lengths)
     return background
コード例 #17
0
def interpolate_cheb(cheb, bands, wave):
    bluest = np.min(bands)  #effective wavelength of bluest filter
    reddest = np.max(bands)  #effective wavelength of reddest filter
    if wave[i] >= reddest or wave[i] <= bluest:
        warnings.warn(
            "The wavelength at which you're interpolating the Chebyshev polynomial is outside the wavelength range of the used bands"
        )

    func = Chebyshev(cheb,
                     domain=[bluest, reddest
                             ])  # This evaluates the Chebyshev polynomial
    return func(wave)
コード例 #18
0
ファイル: bubble.py プロジェクト: evyak/nanobubbles
    def get_free_energy_for_minimize(grid_points):
        """
        Calculates total elastic energy for given radius and pressure.
        """
        global free_energy_elastic_stretching, \
        free_energy_elastic_bending, \
        free_energy_elastic_tail, \
        free_energy_external, \
        current_volume
        
        u_coef = grid_points[:N_COEF_U]
        h_coef = grid_points[N_COEF_U:]
        
        u = Chebyshev(u_coef, domain=[0, radius])
        h = Chebyshev(h_coef, domain=[0, radius])
        r = Chebyshev([radius/2, radius/2], domain=[0, radius])
                
        dh_dr = h.deriv(m=1)
        d2h_dr2 = h.deriv(m=2)
        du_dr = u.deriv(m=1)
        
        current_volume = get_volume_from_h_coefs(h, radius)
        
        psi_str_to_integrate = \
        (du_dr ** 2 + du_dr * dh_dr ** 2 \
         + 0.25 * dh_dr ** 4 \
         + (u // r) ** 2) * r
        
        free_energy_elastic_stretching = np.pi * YOUNGS_MODULUS \
        * (psi_str_to_integrate.integ()(radius) \
           - psi_str_to_integrate.integ()(0.0))
        
        free_energy_elastic_tail = np.pi * YOUNGS_MODULUS * u(radius) ** 2
        
        psi_bend_to_integrate = \
        (d2h_dr2 ** 2 + (dh_dr // r) ** 2) * r
        
        free_energy_elastic_bending = RIGIDITY * np.pi \
        * (psi_bend_to_integrate.integ()(radius) \
           - psi_bend_to_integrate.integ()(0.0))
        
#        free_energy_elastic_bending = 0.0
        
        free_energy_external = -current_volume * pressure        

        return free_energy_elastic_stretching \
               + free_energy_elastic_bending \
               + free_energy_elastic_tail \
               + free_energy_external
コード例 #19
0
def _normalize(spectra):
    stars = spectra.index
    wavelengths = spectra.flux.columns.values.copy()
    flux = spectra.flux.values.copy()
    error = spectra.error.reindex(columns=wavelengths).values.copy()

    #TODO: Should negative fluxes be zero'd too?
    bad_flux = sp.isnan(flux) | sp.isinf(flux)
    bad_error = sp.isnan(error) | sp.isinf(error) | (error < 0)
    bad = bad_flux | bad_error

    flux[bad] = 1
    error[bad] = ERROR_LIM

    #TODO: Where does pixlist come from?
    pixlist = sp.loadtxt('pixlist.txt', dtype=int)
    var = sp.full_like(error, ERROR_LIM**2)
    var[:, pixlist] = 0
    inv_var = 1 / (var**2 + error**2)

    norm_flux = sp.full_like(flux, 1)
    norm_error = sp.full_like(error, ERROR_LIM)
    for star in range(len(stars)):
        for _, (left, right) in CHIPS.items():
            mask = (left < wavelengths) & (wavelengths < right)
            #TODO: Why are we using Chebyshev polynomials rather than smoothing splines?
            #TODO: Why are we using three polynomials rather than one? Are spectra discontinuous between chips?
            #TODO: Is the denominator being zero/negative ever an issue?
            fit = Chebyshev.fit(x=wavelengths[mask],
                                y=flux[star][mask],
                                w=inv_var[star][mask],
                                deg=2)

            norm_flux[star][mask] = flux[star][mask] / fit(wavelengths[mask])
            norm_error[star][mask] = error[star][mask] / fit(wavelengths[mask])

    #TODO: Why is the unreliability threshold different from the limit value?
    unreliable = (norm_error > .3)
    norm_flux[unreliable] = 1
    norm_error[unreliable] = ERROR_LIM

    # In the original, the masking is done in the parallax fitting code.
    # Gonna do it earlier here to save a bit of memory.
    mask = sp.any(
        sp.vstack([(l < wavelengths) & (wavelengths < u)
                   for l, u in CHIPS.values()]), 0)

    norm_flux = pd.DataFrame(norm_flux[:, mask], stars, wavelengths[mask])
    norm_error = pd.DataFrame(norm_error[:, mask], stars, wavelengths[mask])

    return pd.concat({'flux': norm_flux, 'error': norm_error}, 1)
コード例 #20
0
def fit_func(f):
    fn = 'fits/%s/fit%s.fits' % (f, f)
    if os.path.exists(fn):
        r = {}
        d = pyfits.getdata('fits/%s/fit%s.fits' % (f, f), 'fit_info')[0]
        ref = d.field('refwlband')
        low = d.field('lowdwlband') + ref
        high = d.field('highdwlband') + ref
        d = pyfits.getdata('fits/%s/fit%s.fits' % (f, f), 'final_cheb')
        for n in d.names:
            r[n] = Chebyshev(d.field(n), (low, high))
    else:
        r = None
    return r
コード例 #21
0
def cheb_polys():
    resolution = 513
    X = np.linspace(-1, 1, resolution + 1)
    n = 6
    coeffs = np.zeros(n)
    ax = plt.subplot(1, 1, 1)
    for i in xrange(n):
        coeffs[i] = 1
        f = Chebyshev(coeffs)
        plt.plot(X, f(X), label="$T_" + str(i) + "$")
        coeffs[i] = 0
    plt.ylim((-1.2, 1.2))
    handles, labels = ax.get_legend_handles_labels()
    ax.legend(handles, labels, loc="upper right")
    plt.savefig("cheb_polys.pdf")
    plt.clf()
コード例 #22
0
    def roots(self):
        """Utilises Boyd's O(n^2) recursive subdivision algorithm.

        The chebfun
        is recursively subsampled until it is successfully represented to
        machine precision by a sequence of piecewise interpolants of degree
        100 or less. A colleague matrix eigenvalue solve is then applied to
        each of these pieces and the results are concatenated.
        See:
        J. P. Boyd, Computing zeros on a real interval through Chebyshev
        expansion and polynomial rootfinding, SIAM J. Numer. Anal., 40
        (2002), pp. 1666–1682.
        """
        if self.size() == 1:
            return np.array([])

        elif self.size() <= 100:
            ak = self.coefficients()
            v = np.zeros_like(ak[:-1])
            v[1] = 0.5
            C1 = toeplitz(v)
            C2 = np.zeros_like(C1)
            C1[0, 1] = 1.
            C2[-1, :] = ak[:-1]
            C = C1 - .5 / ak[-1] * C2
            eigenvalues = eigvals(C)
            roots = [
                eig.real for eig in eigenvalues if
                np.allclose(eig.imag, 0, atol=1e-10) and np.abs(eig.real) <= 1
            ]
            scaled_roots = self._ui_to_ab(np.array(roots))
            return scaled_roots
        else:
            try:
                # divide at a close-to-zero split-point
                split_point = self._ui_to_ab(0.0123456789)
                return np.concatenate(
                    (self.restrict([self._domain[0], split_point]).roots(),
                     self.restrict([split_point, self._domain[1]]).roots()))
            except:
                # Seems to have many fake roots for high degree fits
                coeffs = self.coefficients()
                domain = self._domain
                possibilities = Chebyshev(coeffs, domain).roots()
                return np.array(
                    [float(i.real) for i in possibilities if i.imag == 0.0])
コード例 #23
0
def runge_plot():
    a, b = -1, 1
    resolution = 513
    runge = lambda x: 1 / (1 + 25 * x**2)
    X2 = np.linspace(a, b, resolution)
    ax = plt.subplot(1, 1, 1)
    plt.plot(X2, runge(X2), label="$\\frac{1}{1+25x^2}$")
    for order in [5, 10, 15, 25]:
        X = nodes(a, b, order)
        Y = runge(X)
        C = get_coefs(Y)
        f = Chebyshev(C)
        plt.plot(X2, f(X2), label="Order " + str(order))
    handles, labels = ax.get_legend_handles_labels()
    ax.legend(handles, labels, loc="upper right")
    plt.savefig("runge_chebyshev.pdf")
    plt.clf()
コード例 #24
0
def cos_interp():
    a = -1
    b = 1
    order = 20
    resolution = 501
    X = nodes(a, b, resolution)
    F = lambda x: np.cos(x)
    A = F(X)
    cfs = get_coefs(A)
    print "number of coefficients for cos that are greater than 1E-14: ", (
        np.absolute(cfs) > 1E-14).sum()
    f = Chebyshev(cfs)
    X2 = np.linspace(a, b, resolution)
    ax = plt.subplot(1, 1, 1)
    plt.plot(X2, F(X2), label="$\\cos x$")
    plt.plot(X2, f(X2), label="Chebyshev Interpolant")
    handles, labels = ax.get_legend_handles_labels()
    ax.legend(handles, labels, loc="upper right")
    plt.show()
コード例 #25
0
def crazy_interp():
    # This one takes a little time to run
    a = -1
    b = 1
    order = 100000
    resolution = 100001
    # Where to sample.
    X = nodes(a, b, order)
    F = lambda x: np.sin(1. / x) * np.sin(1. / np.sin(1. / x))
    A = F(X)
    cfs = get_coefs(A)
    print "The last 10 coeffients are: ", cfs[-10:]
    f = Chebyshev(cfs)
    # Sample values for plot.
    X2 = np.linspace(a, b, resolution)
    ax = plt.subplot(1, 1, 1)
    plt.plot(X2, f(X2), label="Chebyshev Interpolant")
    plt.plot(X2,
             F(X2),
             label="$\\sin\\frac{1}{x} \\sin\\frac{1}{\\sin\\frac{1}{x}}$")
    handles, labels = ax.get_legend_handles_labels()
    ax.legend(handles, labels, loc="upper right")
    plt.show()
コード例 #26
0
ファイル: csolver.py プロジェクト: GeorgeErickson/msketch
    def solve(
            self,
            d_mus:np.ndarray,
            lambd=None,
    ):
        n = self.n
        k = self.k

        if lambd is None:
            lambd = np.zeros(self.k)

        H = np.zeros(shape=(k, k))
        fpoly = None

        for i_step in range(self.n_steps):
            if fpoly is None:
                fvals = np.exp(lambd.dot(self.G))
                cs = fit_cheby(fvals)
                fpoly = Chebyshev(cs)

            e_mu = np.array([
                (fpoly*cb(i)).integ(lbnd=-1)(1)
                for i in range(2*k)
            ])
            grad = e_mu[:k] - d_mus
            grad_norm = np.linalg.norm(grad)

            grad_norm_old = grad_norm
            Pval_old = e_mu[0] - lambd.dot(d_mus)


            if self.verbose:
                print("Step: {}, Grad: {}, P: {}".format(
                    i_step, grad_norm, Pval_old
                ))
            if grad_norm < self.grad_tol:
                break

            for i in range(k):
                for j in range(k):
                    H[i, j] = (e_mu[i+j] + e_mu[abs(i-j)]) / 2
            step = -np.linalg.solve(H, grad)
            dfdx = step.dot(grad)

            stepScaleFactor = 1.0
            newX = lambd + stepScaleFactor * step
            alpha = .3
            beta = .25

            while True:
                fvals = np.exp(newX.dot(self.G))
                cs = fit_cheby(fvals)
                fpoly = np.polynomial.chebyshev.Chebyshev(cs)

                e_mu = np.array([
                    (fpoly * cb(i)).integ(lbnd=-1)(1)
                    for i in range(2 * k)
                ])
                grad = e_mu[:k] - d_mus
                grad_norm = np.linalg.norm(grad)

                Pval_new = fpoly.integ(lbnd=-1)(1) - newX.dot(d_mus)
                delta_change = Pval_old + alpha * stepScaleFactor * dfdx - Pval_new

                # if (delta_change > -1e-6 and grad_norm < grad_norm_old) or stepScaleFactor < 1e-5:
                if (delta_change > -1e-6 or stepScaleFactor < 1e-5):
                    break
                else:
                    stepScaleFactor *= beta
                if self.verbose:
                    print("step: {}, delta: {}".format(stepScaleFactor, delta_change))
                newX = lambd + stepScaleFactor * step

            lambd = newX

        self.lambd = lambd
        self.f_poly = self.get_fpoly(lambd)
        self.cdf_poly = self.f_poly.integ(lbnd=-1)
コード例 #27
0
ファイル: lsq_problems.py プロジェクト: zxsted/scipy
 def __init__(self, x0):
     super(ChebyshevQuadrature, self).__init__(11, 11, 2.799761e-03, x0)
     cp = Chebyshev(1)
     self.T_all = [cp.basis(i, domain=[0.0, 1.0]) for i in range(11)]
コード例 #28
0
def setup_numpy():
    return Chebyshev.interpolate(np.sin, deg=10, domain=(0, 1))
コード例 #29
0
 def nextIter(self):
     VNext = T.interpolate(lambda W: -self.negValue(W),
                           deg=self.order,
                           domain=[self.WMin, self.WMax])
     return VNext
コード例 #30
0
 def guessSln(self):
     self.V = T.interpolate(lambda W: self.u(W + self.y),
                            deg=self.order,
                            domain=[self.WMin, self.WMax])
コード例 #31
0
 def findPolicy(self):
     self.policy = T.interpolate(lambda W: W + self.y -
                                 (self.findOptW1(W) / self.R),
                                 deg=self.order,
                                 domain=[self.WMin, self.WMax])
コード例 #32
0
 def _derivative(c, m):
     cheb = Chebyshev(c)
     dcheb = cheb.deriv(m=m)
     return dcheb.coef