Example #1
0
def integral_full(limits, norm_range, params, model):
    lower, upper = limits.rect_limits  # for a more detailed guide, see the space.py example
    param1 = params['super_param']
    param2 = params['param2']
    param3 = params['param3']

    lower = z.convert_to_tensor(lower)
    upper = z.convert_to_tensor(upper)

    # calculate the integral here, dummy integral, wrong!
    integral = param1 * param2 * param3 + z.reduce_sum([lower, upper])
    return integral
Example #2
0
 def indefinite_integral(limits):
     max_degree = model.degree + 1  # needed +1 for integral, max poly in term for n is n+1
     polys = do_recurrence(x=limits,
                           polys=legendre_polys,
                           degree=max_degree,
                           recurrence=legendre_recurrence)
     one_limit_integrals = []
     for degree in range(1, max_degree):
         coeff = model.params[f"c_{degree}"]
         one_limit_integrals.append(
             coeff * (polys[degree + 1] - polys[degree - 1]) /
             (2. * (z.convert_to_tensor(degree)) + 1))
     return z.reduce_sum(one_limit_integrals, axis=0)
Example #3
0
 def indefinite_integral(limits):
     max_degree = model.degree + 1
     polys = do_recurrence(x=limits,
                           polys=chebyshev_polys,
                           degree=max_degree,
                           recurrence=chebyshev_recurrence)
     one_limit_integrals = []
     for degree in range(2, max_degree):
         coeff = model.params[f"c_{degree}"]
         n_float = z.convert_to_tensor(degree)
         integral = (n_float * polys[degree + 1] /
                     (z.square(n_float) - 1) - limits * polys[degree] /
                     (n_float - 1))
         one_limit_integrals.append(coeff * integral)
     return z.reduce_sum(one_limit_integrals, axis=0)
Example #4
0
 def _auto_ext_integrate(self, limits, norm, *, options):
     try:
         integral = self._ext_integrate(limits=limits, norm=norm, options=options)
     except NormNotImplemented:
         unnormalized_integral = self._auto_ext_integrate(
             limits=limits, norm=False, options=options
         )
         normalization = self.ext_normalization(norm, options=options)
         integral = unnormalized_integral / normalization
     except MultipleLimitsNotImplemented:
         integrals = []  # TODO: map?
         for sub_limits in limits:
             integrals.append(
                 self._auto_integrate(limits=sub_limits, norm=norm, options=options)
             )
         integral = z.reduce_sum(integrals, axis=0)  # TODO: remove stack?
     return integral