dydx | This fork | Frontend Framework library

but for some reason, the precision of my integrator maxes out at 16 significant digits.

At a minimum, use more correct values of long double initialization with long double quotients rather than double quotients.

nquad expects the first argument of the integrand function to be the variable corresponding to the innermost integral. If you change your definition of f to

As juanpa.arrivillaga mentioned in the comments, at least one of the iterables x, y, oneZero is longer than der, and zip_longest will fill the shorter iterables with None values to match the length of the longest iterable.

For example

Yes, what you think about should work, it should be easy to plug together. You want to call

cumtrapz(), cumsum() and similar do what they state they do: summing the input array cumulatively. If the summed array starts with 0 as with your input array (dydx), the first element at the summed array is also zero.
To fix it in your code, you should add the offset to the cumulated sum: dydx_int = dydx_int + y[0]

But for the general question about initial conditions of an integral:

My concern is, if you have some arbitrary signal, and did not know the initial/boundary conditions, will the +constant term be unaccounted for with cumtrapz? Is there a solution for this with cumtrapz?

Well, if you don't know the initial/boundry condition, cumtrapz won't know either... Your question doesn't quite make sense..

There are a couple of ways to do this, but essentially the problem boils down to the fact

$$\Pr(y_{it}=1 \vert x_{it})=\int\Lambda(u_i + x_{it}'\beta)\cdot \varphi(0,\sigma_u^2) du_i$$

where $\varphi()$ is the normal density. In your code, you are effectively setting the random effect $u_i$ to zero (which is what predict(pu0) does). This sets the RE to its average, which may not be what you had it mind. Of course, $u_i$ is not observed or even estimated by xtlogit, re, so if you want to replicate what predict(pr) does, you need to integrate the random effect out to get the unconditional probability using the estimated variance.

One way to do this in Stata is to use the user-written integrate command to do one dimensional numerical integration like this:

The data in sol_matrix is not in contiguous memory, it's in nt separately allocated arrays. Therefore the line

To mimic the behavior of numpy.interp will require several steps. We'll make at least one simplifying assumption: the numpy.interp function expects your xp array to be increasing (we could probably also say "sorted"). Otherwise it specifically mentions a need to do an (internal) sorting. We'll skip that case and assume that your xp array is increasing, as you have shown here.

The numpy function also allows the x array to be more-or-less arbitrary, from what I can see.

In order to do a proper interpolation, we must find the "segment" of xp that each x value belongs to. The only way I can think of is to perform a binary search. (also note that thrust has convenient binary searches)

The process then would be:

1. using a binary search per element in x, find the corresponding "segment" (i.e. endpoints) in xp
2. use the equation of a line (y=mx+b), based on the identified segment, to compute the interpolated value between the endpoints

Here's an example:

With the help of others, I got to this: