• More about my scalable math Linear System Solver Library...

    From World90@21:1/5 to All on Wed Apr 21 15:51:12 2021
    Hello...


    More about my scalable math Linear System Solver Library...

    I am a white arab, and i think i am smart since i have also
    invented many scalable algorithms and algorithms..

    As you have just noticed i have just spoken about my Linear System
    Solver Library(read below), right now it scales very well, but i will
    soon make it "fully" scalable on multicores using one of my scalable
    algorithm that i have invented and i will extend it much more to also
    support efficient scalable on multicores matrix operations and more, and
    since it will come with one of my scalable algorithms that i have
    invented, i think i will sell it too.

    More about mathematics and about scalable Linear System Solver Libraries
    and more..

    I have just noticed that a software architect from Austria
    called Michael Rabatscher has designed and implemented MrMath Library
    that is also a parallelized Library:

    Here he is:

    https://at.linkedin.com/in/michael-rabatscher-6821702b

    And here is his MrMath Library for Delphi and Freepascal:

    https://github.com/mikerabat/mrmath

    But i think that he is not so smart, and i think i am smart like
    a genius and i say that his MrMath Library is not scalable on
    multicores, and notice that the Linear System Solver of his MrMath
    Library is not scalable on multicores too, and notice that the threaded
    matrix operations of his Library are not scalable on multicores too,
    this is why i have invented a scalable on multicores Conjugate Gradient
    Linear System Solver Library for C++ and Delphi and Freepascal, and here
    it is, read about it in my following thoughts(also i will soon extend
    more my Library to support scalable matrix operations):

    About SOR and Conjugate gradient mathematical methods..

    I have just looked at SOR(Successive Overrelaxation Method),
    and i think it is much less powerful than Conjugate gradient method,
    read the following to notice it:

    COMPARATIVE PERFORMANCE OF THE CONJUGATE GRADIENT AND SOR METHODS
    FOR COMPUTATIONAL THERMAL HYDRAULICS

    https://inis.iaea.org/collection/NCLCollectionStore/_Public/19/055/19055644.pdf?r=1&r=1


    This is why i have implemented in both C++ and Delphi my Parallel
    Conjugate Gradient Linear System Solver Library that scales very well,
    read my following thoughts about it to understand more:


    About the convergence properties of the conjugate gradient method

    The conjugate gradient method can theoretically be viewed as a direct
    method, as it produces the exact solution after a finite number of
    iterations, which is not larger than the size of the matrix, in the
    absence of round-off error. However, the conjugate gradient method is
    unstable with respect to even small perturbations, e.g., most directions
    are not in practice conjugate, and the exact solution is never obtained. Fortunately, the conjugate gradient method can be used as an iterative
    method as it provides monotonically improving approximations to the
    exact solution, which may reach the required tolerance after a
    relatively small (compared to the problem size) number of iterations.
    The improvement is typically linear and its speed is determined by the condition number κ(A) of the system matrix A: the larger is κ(A), the
    slower the improvement.

    Read more here:

    http://pages.stat.wisc.edu/~wahba/stat860public/pdf1/cj.pdf


    So i think my Conjugate Gradient Linear System Solver Library
    that scales very well is still very useful, read about it
    in my writing below:

    Read the following interesting news:

    The finite element method finds its place in games

    Read more here:

    https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fhpc.developpez.com%2Factu%2F288260%2FLa-methode-des-elements-finis-trouve-sa-place-dans-les-jeux-AMD-propose-la-bibliotheque-FEMFX-pour-une-simulation-en-temps-reel-des-
    deformations%2F

    But you have to be aware that finite element method uses Conjugate
    Gradient Method for Solution of Finite Element Problems, read here to
    notice it:

    Conjugate Gradient Method for Solution of Large Finite Element Problems
    on CPU and GPU

    https://pdfs.semanticscholar.org/1f4c/f080ee622aa02623b35eda947fbc169b199d.pdf


    This is why i have also designed and implemented my Parallel Conjugate
    Gradient Linear System Solver library that scales very well,
    here it is:

    My Parallel C++ Conjugate Gradient Linear System Solver Library
    that scales very well version 1.76 is here..

    Author: Amine Moulay Ramdane

    Description:

    This library contains a Parallel implementation of Conjugate Gradient
    Dense Linear System Solver library that is NUMA-aware and cache-aware
    that scales very well, and it contains also a Parallel implementation of Conjugate Gradient Sparse Linear System Solver library that is
    cache-aware that scales very well.

    Sparse linear system solvers are ubiquitous in high performance
    computing (HPC) and often are the most computational intensive parts in scientific computing codes. A few of the many applications relying on
    sparse linear solvers include fusion energy simulation, space weather simulation, climate modeling, and environmental modeling, and finite
    element method, and large-scale reservoir simulations to enhance oil
    recovery by the oil and gas industry.

    Conjugate Gradient is known to converge to the exact solution in n steps
    for a matrix of size n, and was historically first seen as a direct
    method because of this. However, after a while people figured out that
    it works really well if you just stop the iteration much earlier - often
    you will get a very good approximation after much fewer than n steps. In
    fact, we can analyze how fast Conjugate gradient converges. The end
    result is that Conjugate gradient is used as an iterative method for
    large linear systems today.

    Please download the zip file and read the readme file inside the zip to
    know how to use it.

    You can download it from:

    https://sites.google.com/site/scalable68/scalable-parallel-c-conjugate-gradient-linear-system-solver-library

    Language: GNU C++ and Visual C++ and C++Builder

    Operating Systems: Windows, Linux, Unix and Mac OS X on (x86)



    Thank you,
    Amine Moulay Ramdane.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)