def _setup_approximants(self): return [ Chebyshev.interpolate(self.function, self.degree, domain=window, *self.args) for window in self._windows ]
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
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
def setup_numpy(): return Chebyshev.interpolate(np.sin, deg=10, domain=(0, 1))
def nextIter(self): VNext = T.interpolate(lambda W: -self.negValue(W), deg=self.order, domain=[self.WMin, self.WMax]) return VNext
def guessSln(self): self.V = T.interpolate(lambda W: self.u(W + self.y), deg=self.order, domain=[self.WMin, self.WMax])
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])