eigen | linear algebra : matrices , vectors , numerical solvers | Math library

Finally, I put this to the side for some time when I got more R savvy. Instead of trying to overcomplicate things, I decided to make a really simple SEM path plot, then apply what was said in the comments here earlier to solve the issue.

So the major issue I kept having was getting the title to map on. For some reason I couldn't understand what was causing the issue...until I figured out the order of operations for printing out the plot. So here is basically what I did. First I used a well-oiled data frame and wrote a model based off the old lavaan manual:

Rcpp::wrap is dispatching to a method for Eigen matrices and vectors implemented in RcppEigen. That method doesn't appear to support long vectors, currently. (Edit: It now does; see below.)

The error about negative length is thrown by allocVector3 here. It arises when allocVector3 is called with a negative value for its argument length. My guess is that Rcpp::wrap tries to represent 2^31 as an int, resulting in integer overflow. Maybe this happens here?

In any case, you seem to have stumbled on a bug, so you might consider sharing your example with the RcppEigen maintainers on GitHub. (Edit: Never mind - I've just submitted a patch.) (Edit: Patched now, if you'd like to build RcppEigen from sources [commit 5fd125e or later] in order to update your Rcpp::wrap.)

Attempting to answer your first question, I compared your two approaches with my own based on std::memcpy. The std::memcpy approach supports long vectors and is only slightly slower than Rcpp::wrap.

The C arrays beneath Eigen::VectorXi x and Rcpp::IntegerVector y have the same type (int) and length (n), so they contain the same number of bytes. You can use std::memcpy to copy that number of bytes from one's memory address to other's without a for loop. The hard part is knowing how to obtain the addresses. Eigen::VectorXi has a member function data that returns the address of the underlying int array. R objects of integer type use INTEGER from the R API, which does the same thing.

Is this a bug of std::ranges::size?

No. The cppreference documentation is misleading. There is no requirement for std::ranges::size to return an unsigned integer. In this case, it returns exactly what Eigen::VectorXd::size returns.

For ranges that model ranges::sized_range, that would be an unsigned integer, but Eigen::VectorXd evidently does not model such range.

But then what is the purpose of std::ranges::ssize compared to std::ranges::size?

The purpose of std::ranges::ssize is to be a generic way to get a signed value regardless of whether std::ranges::size returns signed or unsigned. There is no difference between them in cases where std::ranges::size returns a signed type.

Is there a reference to back up what you state?

Yes. See the C++ standard:

[range.prim.size]

Otherwise, if disable_­sized_­range> ([range.sized]) is false and auto(t.size()) is a valid expression of integer-like type ([iterator.concept.winc]), ranges​::​size(E) is expression-equivalent to auto(​t.size()).

Contiguous ranges have to be opted into. There is no way to determine just by looking at an iterator whether or not it is contiguous or just random access. Consider the difference between deque::iterator and vector::iterator - they provide all the same operations that return all the same things, how would you know unless the vector::iterator explicitly told you?

Eigen's iterators do not do this yet. Indeed, before C++20 there was no notion of a contiguous iterator to begin with. That's new with C++20 Ranges.

You can see this if you try to just verify that it is contiguous:

In the first version,

Thanks to @ead I found a solution.

FlattenedMapWithOrder has implementation so it can be assinged to an Eigen::Matrix. However, std::vector does not have such functionality and since std::vector and std::vector are of a different type, they cannot be assigned to one another. More about this here. The implementation in FlattenedMapWithOrder mentioned above is here.

To solve this, the function in the C++ code called from Cython need to simply have as input argument the matching type: std::vector. To do this, the C++ code needs to know the definition of type FlattenedMapWithOrder.

To do this, you need to #include "eigency_cpp.h". Unfortunately, this header is not self contained. Therefore, (credits to @ead) I added these lines:

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.

As seen in the output you've provided, there are 2 problems:

1. There is a target name conflict between probably CppAD and eigen. They both have the uninstall target. It can be seen here:

As suggested by INS in the comment is the actual copying of the matrix causing the performance drop, I slightly modify your example to use some numbers instead of all zeros (to avoid any type of optimisation):