blas | A BLAS implementation for Go

I am compiling with: g++ -lblas -llapack -llapacke -I /usr/include main.cpp

That command line is wrong. Do this instead:

The master branch of rfigshare seems to be out of sink with what figshare now offers in that the master branch seems to use v1 of the api along with oauth v1 authentication whereas figshare has moved on with v2 of the api and now promotes the use of oauth v2.

While I am unsure whether figshare has shutdown v1 of the api and/or has disallowed oauth v1, it seems like you might still be able to use the package if you install from the sckott branch and use a personal access token (PAT).

To generate a PAT, navigate to https://figshare.com/account/applications in a web browser. At the bottom of this page, you can generate a PAT. When the token is presented, copy it as you will not be able to view it again (although you can easily generate a new one at any time).

You will want to store this token in your .Renviron file. The usethis package has a nifty edit_r_environ() function to make this a little easier:

Ok, I have a solution that has not failed for me: I create a try catch with a max attempt iterator, default 5 attempts with a wait time of 1 second, in addition to a general wait time of 0.05 seconds per accepted url request.

Let me know if anyone has a safer idea:

In my experience, these errors on Unix often stem from missing external libraries. For example, installing the R xml2 package requires libxml2-dev to be installed via the system package manager (i.e. outside R) otherwise installation will fail.

I can't read French, but it looks to me as though the dependency jpeg failed, due to a missing external jpeg library, and then everything cascaded from there. You could try installing some version of the libjpeg library. I know it comes pre-installed in Ubuntu which may be why that worked for you. I'm a little surprised it doesn't come installed already in OpenSUSE, but I have no experience with OpenSUSE.

We could subset with .data

The problem was solved by setting

Computing transpositions efficiently is hard. This primitive is not compute-bound but memory-bound. This is especially true for big matrices stored in the RAM (and not CPU caches).

Numpy use a view-based approach which is great when only a slice of the array is needed and quite slow the computation is done eagerly (eg. when a copy is performed). The way Numpy is implemented results in a lot of cache misses strongly decreasing performance when a copy is performed in this case.

I found this function virtually always run in single-threaded, whatever how large the transposed matrix/array is.

This is clearly dependant of the Numpy implementation used. AFAIK, some optimized packages like the one of Intel are more efficient and take more often advantage of multithreading.

I think a parallelized transpose function should be a resolution. The problem is how to implement it.

Yes and no. It may not be necessary faster to use more threads. At least not much more, and not on all platforms. The algorithm used is far more important than using multiple threads.

On modern desktop x86-64 processors, each core can be bounded by its cache hierarchy. But this limit is quite high. Thus, two cores are often enough to nearly saturate the RAM throughput. For example, on my (4-core) machine, a sequential copy can reach 20.4 GiB/s (Numpy succeed to reach this limit), while my (practical) memory throughput is close to 35 GiB/s. Copying A takes 72 ms while the naive Numpy transposition A takes 700 ms. Even using all my cores, a parallel implementation would not be faster than 175 ms while the optimal theoretical time is 42 ms. Actually, a naive parallel implementation would be much slower than 175 ms because of caches-misses and the saturation of my L3 cache.

Naive transposition implementations do not write/read data contiguously. The memory access pattern is strided and most cache-lines are wasted. Because of this, data are read/written multiple time from memory on huge matrices (typically 8 times on current x86-64 platforms using double-precision). Tile-based transposition algorithm is an efficient way to prevent this issue. It also strongly reduces cache misses. Ideally, hierarchical tiles should be used or the cache-oblivious Z-tiling pattern although this is hard to implement.

Here is a Numba-based implementation based on the previous informations:

You are renaming the factor levels instead of releveling the factor. To fix that, try:

alright, so, it seems that they give you the output of conda list rather than the .yml file produced by conda with conda env export > myenv.yml. Therefore you have two solutions:

1. You ask for the proper file and then proceed to install the env with conda built-in pipeline

2. If you do not have any access on the proper file, you could do one of the following:

   i) Parse with python into a proper .yml file and then do the conda procedure.

   ii) Do a bash script, downloading the packages listed in the file she gave you.

This is how I would proceed, personally :)