LLT | Robust Feature Matching for Remote Sensing Image | Machine Learning library

I may be reading the Eigen documentation differently: I do not think you can 'pick' elements from a matrix or vector by injecting an integer vector. If it did as you do above with nz then the simpler below would compile. But it doesn't. Meaning your very clever and very highly aggregate 'update' expression does not work.

Right now you are checking if both if conditions are true:

As long as the actual "records" are not too long I would use the DLMSTR= option to process the file twice. First to parse the "records" into lines. Then to read the fields from the lines.

So first make a new text file that has one line per record.

Just pass the LLT object as a standard C++ constant reference.

Passing kxstarxstar and kxxstar by Eigen::Ref also only makes sense, if you intend to pass sub-blocks of other matrices. If not, just pass them as const Eigen::MatrixXd &. If you want to pass them as Eigen::Ref, it is recommended to pass that itself as const &:

The simple non-compiler answer would be that you're asking for the LLT to solve in-place (i.e. in the passed parameter) so what would you expect the result to be? Apparently, you would expect it to be a compiler error, as the "in-place" means change the parameter, but you're passing a const object.

So, if we search the Eigen docs for solveInPlace, we find the only item that takes a const reference to have the following note:

"in-place" version of TriangularView::solve() where the result is written in other

Warning
The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here. This function will const_cast it, so constness isn't honored here.

The non-in-place option would be:

the src folder should be part of the export, try this one:

I think you're making this harder than it needs to be.

However many dimensions you have, flatten it to 2D; you're not using anything deeper than a list of 3-element lists.

Now simply make a list of sets, the elements in each dimension

First check perf counters for arith.divider_active being ~= core clock cycles.

98% of the function runtime can be explained by taking the number of square roots and the operation throughput.

Or that works too.

If that's the case, you're saturating the (not fully pipelined) divider throughput and there's not much left to gain from just exposing more ILP.

Algorithmic changes are your only real chance to gain anything, e.g avoid some sqrt operations or use single-precision.

Single-precision gives you 2x as much work per vector for free. But for sqrt-heavy workloads there's an additional gain: vsqrtps throughput per vector is usually better than vsqrtpd. That's the case on Skylake: one per 6 cycles vs. vsqrtpd at one per 9 to 12 cycles. That could move the bottleneck away from the sqrt/divide unit, perhaps to the front-end or the FMA unit.

vrsqrtps has been suggested in comments. That would be worth considering (if single-precision is an option), but it's not a clear win when you need a Newton Raphson iteration to get enough precision. Bare x * rsqrtps(x) without Newton Raphson is probably too inaccurate (and needs a cmp/AND to work around x==0.0), but an NR iteration can take too many extra FMA uops to be worth it.

(AVX512 with vrsqrt14ps/pd has more precision in the approximation, but usually still not enough to use without Newton. But interestingly it does exist for double-precision. Of course if you're on Xeon Phi, sqrt is very slow and you're intended to use AVX512ER vrsqrt28pd + Newton, or just vrsqrt28ps on its own.)

Last time I tuned a function including a sqrt of a polynomial-approximation for Skylake, fast-approx reciprocals weren't worth it. Hardware single-precision sqrt was the best choice that gave us the required precision (and we weren't even considering needing double). There was more work than yours between sqrt operations, though.