Fastor VS librapid

I'm going to throw in a recommendation for Fastor. It is generally faster than other libraries, is very lightweight, and has a pretty modern syntax.

There are C++ libraries that deal with linear algebra and tensors that are able to produce fully vectorized code without requiring you to mess around with SIMD intrinsics. See, for instance, fastor, blaze, eigen and the huge Trillinos set of packages. C++ is very widely used when it comes to scientific HPC applications. All you need to do is google search or better yet, join r/cpp and r/cpp_questions and start asking away for the things you need. The C++ community is very welcoming and full of experts that will be able to help you.

Picking what size you are targeting is really important, though. Could the matrices you are working with realistically be bigger than say 32x32? BLAS is good for big matrices. It's not as great for small matrices. Eigen or Fastor will do better for these smaller problems. And for various common operations on sizes 2, 3, and 4, hand coded graphics-oriented libraries might outperform those.

Tensorflow, Machine learning: https://www.tensorflow.org/ Fastor, A tensor library: https://github.com/romeric/Fastor GNU Scientific Library(GSL): https://www.gnu.org/software/gsl/ Boost. FEniCS, A finite element library: https://fenicsproject.org/ Intel MKL, a BLAS+LAPACK+other goodies library: https://software.intel.com/content/www/us/en/develop/tools/math-kernel-library.html SuiteSparse, A sparse linear algebra library: http://faculty.cse.tamu.edu/davis/suitesparse.html Sundials, Nonlinear solvers: https://computing.llnl.gov/projects/sundials

In addition to all of these changes, I used LibRapid and Surge to write a simple Flappy Bird genetic AI as a proof of concept. The code runs well on all platforms and can simulate over 20,000 birds without too much trouble. If you want to check it out, here's the GitHub page: https://github.com/Pencilcaseman/FlappyBirdAI

LibRapid: https://github.com/LibRapid/librapid Documentation: https://librapid.readthedocs.io/en/latest/

tl;dr

I'm developing an incredibly fast library for arrays and mathematics, and I've implemented a few new features and made some improvements. I'd love for you to check it out!

Links:

GitHub: https://github.com/LibRapid/librapid/

Documentation: https://librapid.readthedocs.io/en/latest/

Discord: https://discord.com/invite/cGxTFTgCAC

Hey everyone!

I am the lead developer of LibRapid (https://github.com/LibRapid/librapid/), a high-performance C++ library for array manipulation and mathematics. I've been working hard to bring you some significant updates and improvements to the library, and I'm excited to share them with you! These changes will make it even easier for you to use LibRapid in your projects and enable you to do even more with it.

Here's a rundown of the most notable changes:

CUDA improvements: We've fixed several bugs and made performance enhancements for the CUDA implementation.

Expanded support for BLAS libraries: LibRapid now has greater support for BLAS libraries, including Intel's MKL.

Test suite and documentation updates: We've updated our test suite and overhauled the documentation for clarity and ease of use.

Matrix Transposition: The library now supports matrix transposition with highly optimised, architecture-specific SIMD implementations and generic implementations for non-trivial types.

New math utility functions: We've added various new utility functions for complex numbers, multi-precision arithmetic, and more.

Matrix transposition and SIMD: LibRapid now supports matrix transposition and SIMD matrix transpose for SSE and AVX2, improving performance and memory alignment.

Random number generation: We've started implementing a new random number generation library.

Fast Fourier Transforms: LibRapid now supports fast Fourier transforms on 1D arrays, with more features coming soon! (We're using FFTW, so you can be sure you are getting the best possible performance)

Array BLAS operations: We're implementing BLAS functions that operate on our high-level array type, allowing you to access the high-performace, specialised routines without the tedious interface. (Many operations already use BLAS functions internally)

You can find more detailed information about the library and example code and usage guides in the documentation (https://librapid.readthedocs.io/en/latest/).

We're always looking for feedback and contributions, so if you're interested in using LibRapid or helping out, please feel free to create a pull request or contact us via our Discord Server (https://discord.com/invite/cGxTFTgCAC). I'm putting in a lot of effort to enhance LibRapid and would greatly appreciate any sponsorships to support my work. If you or your organisation is interested in sponsoring LibRapid, please feel free to reach out to me to discuss your ideas.

We hope you enjoy the latest updates to LibRapid, and look forward to seeing what you build with it!

I am the lead developer of LibRapid, a high-performance C++ library for array manipulation and mathematics. I've been working hard to bring you some significant updates and improvements to the library, and I'm excited to share them with you! These changes will make it even easier for you to use LibRapid in your projects and enable you to do even more with it.

LibRapid is a high-performance C++ library focusing primarily on linear algebra operations, though also supporting a wide range of classes, functions and utilities such as vectors, complex numbers and more.

LibRapid GitHub Repository

Probably LibRapid, which is my high-performance array library for C++. Nothing huge but I'm quite proud of the features it currently implements (given time restrictions and rewrites) and it is, in many cases, faster than things like Eigen and XTensor :)