linalg | single header , public domain | Reflection library

You can use a dictionary to keep track of the indices for each point.

Then, you can iterate over the items in the dictionary, printing out the indices corresponding to points that appear more than once. The runtime of this procedure is linear, rather than quadratic, in the number of points in A:

You will have to explicitly set the shapes of the tensors coming from tf.py_functions. Using None will allow variable input lengths. The Bert output dimension (384,) is, however, necessary:

You can use the multi_dot function:

TL;DR: up to O(32 n²) bytes for a (n,n) input matrix of type float64.

numpy.linalg.inv calls _umath_linalg.inv internally without performing any copy or creating any additional big temporary arrays. This internal function itself calls LAPACK functions internally. As far as I understand, the wrapping layer of Numpy is responsible for allocating the output Numpy matrix. The C code itself allocates a temporary array (see: here). No other array allocations appear to be performed by Numpy for this operation. There are several Lapack implementation and so it is not possible to generally know how much memory is requested by Lapack calls. However, AFAIK, almost all Lapack implementations does not allocate data in your back: the caller has to do it (especially for sgesv/dgesv which is used here). Assuming the (n, n) input matrix is of type float64 and FORTRAN integers are 4-byte wise (which should be the case on most platform, especially on Windows), then the actual memory required (taken by both the input matrix, the output matrix and the temporary matrix) is 8 n² + 8 n² + (8 n² + 8 n² + 4 n) bytes which is equal to (32 n + 4) n or simply O(32 n²) bytes. Note that the temporary buffer is the maximum size and may not be fully written which mean that the OS can physically map (ie. reserve in physical RAM) only a fraction of the allocated space. This is what happens on my (Linux) machine with OpenBLAS: only 24 n² bytes appear to be actually physically mapped. For float32 matrices, it is half the space.

All you need is just reshape F[:, 3] (only f(x, y, z)) into a grid. Hard to be more precise without sample data:

If the data is not sorted, you need to sort it:

You can use different environments for the comparison of Numpy with and without MKL. In each environment you can install the needed packages(numpy with MKL or without) using package installer. Then on that environments you can run your program to compare the performance of Numpy with and without MKL.

NumPy doesn’t depend on any other Python packages, however, it does depend on an accelerated linear algebra library - typically Intel MKL or OpenBLAS.

• The NumPy wheels on PyPI, which is what pip installs, are built with OpenBLAS.

• In the conda defaults channel, NumPy is built against Intel MKL. MKL is a separate package that will be installed in the users' environment when they install NumPy.

• When a user installs NumPy from conda-forge, that BLAS package then gets installed together with the actual library.But it can also be MKL (from the defaults channel), or even BLIS or reference BLAS.

Please refer this link to know about installing Numpy in detail.

You can create two different environments to compare the NumPy performance with MKL and without it. In the first environment install the stand-alone NumPy (that is, the NumPy without MKL) and in the second environment install the one with MKL.

To create environment using NumPy without MKL.

I just tried the case of setting vectorB as a multiple of vectorA and - interestingly - it sometimes produces nan, sometimes 0 and sometimes it fails and produces a small angle of magnitude 1e-8 ... any ideas why?

Yea and I think that's what your question boils down to. Here is the formula from the berkeley paper due to Kahan that you've been using. Assuming that a≥b, a≥c (only then is the formula valid) and b+c≈a. If we ignore mu for a second and look at everything else under the square root it must all be positive since a is the longest side. And mu is c-(a-b) which is 0 ± a small error. If that error is zero you get zero which is btw. the correct result. If the error is negative the square root gives you nan and if the error is positive you get a small angle.

Notice that the same argument works when b+c-a is non zero but smaller than the error.

Your Julia example code isn't actually using Julia's multithreading capabilities.

In Julia, if you want multithreading, you generally need to enable it explicitly. Functions like mean or cov will not automatically be multithreaded just by virtue of starting Julia with multiple threads; if you want these functions to multithread, you will need to either write multithreaded versions of them, or else use a package that has already done so.

The only thing in your Julia example code that will multithread at all as currently written would be the linear algebra, because that falls back to BLAS (as indeed likely does numpy), which has its own multithreading system entirely separate from Julia's multithreading (BLAS is written in Fortran). That is also probably not using all 96 threads either though, and in your case is almost certainly defaulting to 8. The number of threads used by BLAS in Julia can be checked with

You can use Cartesian coordinate instead of Spherical coordinate.

The default norm parameter ('euclidean') used by Rbf is sufficient