Monday, May 21, 2018

Digest for comp.programming.threads@googlegroups.com - 13 updates in 12 topics

Sky89 <Sky89@sky68.com>: May 21 01:07AM -0400

Hello..
 
Read this:
 
 
Read this very interesting webpage about artificial intelligence:
 
The Deep Learning Rut
 
https://humanizing.tech/the-deep-learning-rut-d7ba5c66aef1
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 21 12:44AM -0400

Hello..
 
Read this:
 
 
More precision:
 
A heuristic technique (/hjʊəˈrɪstɪk/; Ancient Greek: εὑρίσκω, "find" or
"discover"), often called simply a heuristic, is any approach to problem
solving, learning, or discovery that employs a practical method not
guaranteed to be optimal or perfect, but sufficient for the immediate
goals. Where finding an optimal solution is impossible or impractical,
heuristic methods can be used to speed up the process of finding a
satisfactory solution. Heuristics can be mental shortcuts that ease the
cognitive load of making a decision. Examples of this method include
using a rule of thumb, an educated guess, an intuitive judgment,
guesstimate, stereotyping, profiling, or common sense.
 
 
Read here:
 
https://en.wikipedia.org/wiki/Heuristic
 
 
And read also the following because it is important and it says:
 
1- Human brains, are intuition machines. Intuition is that parallel
cognitive process that we develop by learning using induction. Said
differently, we learn from experience. We can't just upload knowledge of
Kung Fu and instantly master the art. Humans require years of practice
 
 
2- Human cognition is a heuristic system that is heavily flawed but can
react and adapt extremely rapidly.
 
 
3- Computers are logic machines, computers have several orders of
magnitude more capable in performing logic than humans. A simple hand
calculator has more arithmetic intelligence than any human alive.
 
 
Read the following very interesting webpage to understand:
 
Are Biological Brains Made Of Only Discrete Logic?
 
https://medium.com/intuitionmachine/brains-are-intuition-machines-and-are-driven-by-discrete-computation-e210d2e03501
 
 
So from the above and from 2 above, that means since human cognition is
a "heuristic" system that is heavily flawed but can react and adapt
extremely rapidly, we can say that to be more "precision" and more
"logic" and more "calculations" and to be more "mathematical"
sophistication and more "sophistication", we human need softwares and we
need computers and we need internet and we need artificial intelligence etc.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 21 12:20AM -0400

Hello,
 
 
Read the following because it is important and it says:
 
1- Human brains, are intuition machines. Intuition is that parallel
cognitive process that we develop by learning using induction. Said
differently, we learn from experience. We can't just upload knowledge of
Kung Fu and instantly master the art. Humans require years of practice
 
 
2- Human cognition is a heuristic system that is heavily flawed but can
react and adapt extremely rapidly.
 
 
3- Computers are logic machines, computers have several orders of
magnitude more capable in performing logic than humans. A simple hand
calculator has more arithmetic intelligence than any human alive.
 
 
Read the following very interesting webpage to understand:
 
Are Biological Brains Made Of Only Discrete Logic?
 
https://medium.com/intuitionmachine/brains-are-intuition-machines-and-are-driven-by-discrete-computation-e210d2e03501
 
 
So from the above and from 2 above, that means since human cognition is
a heuristic system that is heavily flawed but can react and adapt
extremely rapidly, we can say that to be more "precision" and more
"logic" and more "calculations" and to be more "mathematical"
sophistication and more "sophistication", we human need softwares and we
need computers and we need internet and we need artificial intelligence...
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 09:51PM -0400

Hello..
 
 
What about garbage collection?
 
Read what said this serious specialist called Chris Lattner:
 
"One thing that I don't think is debatable is that the heap compaction
behavior of a GC (which is what provides the heap fragmentation win) is
incredibly hostile for cache (because it cycles the entire memory space
of the process) and performance predictability."
 
"Not relying on GC enables Swift to be used in domains that don't want
it - think boot loaders, kernels, real time systems like audio
processing, etc."
 
"GC also has several *huge* disadvantages that are usually glossed over:
while it is true that modern GC's can provide high performance, they can
only do that when they are granted *much* more memory than the process
is actually using. Generally, unless you give the GC 3-4x more memory
than is needed, you'll get thrashing and incredibly poor performance.
Additionally, since the sweep pass touches almost all RAM in the
process, they tend to be very power inefficient (leading to reduced
battery life)."
 
Read more here:
 
https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160208/009422.html
 
Here is Chris Lattner's Homepage:
 
http://nondot.org/sabre/
 
And here is Chris Lattner's resume:
 
http://nondot.org/sabre/Resume.html#Tesla
 
 
This why i have invented the following scalable algorithm and its
implementation that makes Delphi and FreePascal more powerful:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 09:35PM -0400

Hello..
 
 
Read what our "brother" Bill Gates wants to say:
 
If Bill Gates were in college today, here's what he would study:
 
https://www.cnbc.com/2018/04/27/if-bill-gates-were-at-harvard-today-heres-what-he-would-study.html
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 08:25PM -0400

Hello,
 
 
Capitalism does also transcend nationalism and racism
 
Because economic growth and wealth come from work and ideas of other
races like arabs.. this is the essence of capitalism , and it was
well understood by our "brother" Bill Gates of Microsoft, the essence of
capitalism must be understood better and applied better to be able to
transcend "nationalism" and "racism", this is why i am here, i love also
a correct capitalism that is more smart ! this is why you have
seen me talking about Linux and Java this way by saying:
 
How can you bring growth and wealth ?
 
You have to be commercial so that to protect for example your scalable
algorithms and be more competitive , this
creates growth and wealth. And you have to protect your
new competitive "ideas" or be rapid with your new competitive ideas so
that to be competitive and bring growth and wealth.
 
You have to know me more..
 
You will think that i am stupid because i use modern Object Pascal
of Delphi and FreePascal that supports inline assembler and generics
etc. but as you are noticing i am not stupid because i am an "inventor"
of many "scalable" algorithms, i am "making" the world with my my kind
of smartness, i am not waiting for the "standards" of Java or the
standard of C++ or Rust, because they are also inferiority because
many of there algorithms are not "scalable", this is why i am here,
because i have brought my scalable algorithms to Delphi and FreePascal
and C++, look at my following last invention that is:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
Where do you will find it ? you will not find it in C++ and you will not
find it in ADA. This is why i am here, i am making the world ! i am not
waiting for C++ or Java or Rust. This is how you have to be this kind of
smartness ! i have also invented a scalable queue and a scalable
Threadpool and many of my other scalable algorithms.
 
And look for example at my efficient Threadpool engine that scales very
well here:
 
https://sites.google.com/site/aminer68/an-efficient-threadpool-engine-that-scales-very-well
 
It says this:
 
More precision about my efficient Threadpool that scales very well, my
Threadpool is much more scalable than the one of Microsoft, in the
workers side i am using scalable counting networks to distribute on the
many queues or stacks, so it is scalable on the workers side, on the
consumers side i am also using lock striping to be able to scale very
well, so it is scalable on those parts, on the other part that is work
stealing, i am using scalable counting networks, so globally it scales
very well, and since work stealing is "rare" so i think that my
efficient Threadpool that scales very well is really powerful, and it is
much more optimized and the scalable counting networks eliminate false
sharing, and it works with Windows and Linux.
 
So as you have noticed i am making the world and not waiting for Java or
C++ or Rust.
 
Also look at my Parallel Compression Library and my Parallel archiver,
you will not find them anywhere, read about them and you will notice it,
they are NUMA efficient and now my Parallel compression library and my
Parallel archiver are optimized for NUMA and they support processor
groups on windows and they use only two threads that do the IO (and they
are not contending) so that it reduces at best the contention, so that
they scale well, also now the process of calculating the CRC is much
more optimized and is fast, and the process of testing the integrity is
fast. I have done a quick calculation of the scalability prediction for
my Parallel Compression Library, and i think it's good: it can scale
beyond 100X on NUMA systems, read about them and download them from here
 
https://sites.google.com/site/aminer68/parallel-archiver
 
https://sites.google.com/site/aminer68/parallel-compression-library
 
 
And you will find many of my scalable algorithms implementation here:
 
https://sites.google.com/site/aminer68/
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 07:14PM -0400

Hello,
 
Read again, i correct
 
 
I think C++ and C have many problems because they are "too" weakly
typed, here is another problem of C++ and C, look at this C++ example:
 
 
===
 
#include <conio.h>
#include <iostream>
using namespace std;
#include <stdint.h>
 
 
 
double y;
 
 
void a1(unsigned int a)
{
cout << a ;
 
}
 
int main()
{
 
unsigned int b;
int a;
 
 
 
y=3.4;
 
 
a1(y);
 
 
}
 
==
 
 
This will be accepted by C++ because the parameter a of a1() will equal
3, but this is "not" correct for "reliability" and it is not accepted by
Delphi and FreePascal and ADA because they are more strongly typed than
C++ and C and they will give an error that the type of the parameter a
of a1() is not the same as the type of y.
 
 
Also Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking and don't have many Run-time
checks etc. so that's not good in C++ and C because it is not good for
reliability and it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
And about Escher C++ Verifier, read carefully:
 
"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."
 
Read here:
 
http://www.eschertech.com/products/index.php
 
 
So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again that C++ and C don't have range checking and many
Run-time checks, so that's not good in C++ and C because it is not good
for reliability and it is not good for safety-critical systems.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 08:04PM -0400

Hello....
 
Read again, i correct
 
Delphi is much more rapid/RAD development solution than C++ and the
horror that was MFC. Delphi VCL was also more complete than what Visual
Basic,on the other hand with the new Delphi LLVM compilers there is a
promise for more platforms and better low-level performance,
 
Here is the new LLVM-based Delphi compilers:
 
http://docwiki.embarcadero.com/RADStudio/Tokyo/en/LLVM-based_Delphi_Compilers
 
 
I think i will also continu to work more with Delphi and FreePascal and
Lazarus, all of them use a "modern" Object Pascal that is much more
powerful than pascal, you have to look at the new Delphi language that
is powerful, i am also using the Delphi mode with FreePascal to be
compatible with Delphi.
 
Delphi for example works on the following platforms:
 
Windows
Linux
macOS
iOS
Android
 
You have to look at the new Delphi here, it is very powerful:
 
https://www.embarcadero.com/products/delphi
 
 
Lazarus and FreePascal are very interesting to use, you have to look
at Lazarus here to notice it:
 
https://www.lazarus-ide.org/
 
 
What i love in Delphi and FreePascal is that
Delphi and FreePascal like ADA are more strongly typed than C++ or C and
they come with range checking and Run-time checks that catch conversion
from negative signed to unsigned , and catch out-of-bounds indices of
dynamic and static arrays and catch arithmetic overflow etc. and you can
also dynamically catch this exception of ERangeError etc. and that's
good for reliability.
 
But C++ and C don't have range checking and many Run-time checks etc. so
that's not good in C++ and C and that's not good for reliability and it
is not good for safety-critical systems.
 
 
This is why i will also to continu to work more with Delphi and
FreePascal and Lazarus, and my Delphi projects can be used with C++Builder.
 
Look for example at my last invention , here is my last invention for
Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
You can find my other "inventions"(that are my scalable algorithms etc.)
and my other projects here:
 
https://sites.google.com/site/aminer68/
 
Also you can improve strict-type safety(and thus reliability) in Delphi
and FreePascal with variants like this:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
I think C++ and C have many problems because they are "too" weakly
typed, here is another problem of C++ and C, look at this C++ example:
 
 
===
 
#include <conio.h>
#include <iostream>
using namespace std;
#include <stdint.h>
 
 
 
double y;
 
 
void a1(unsigned int a)
{
cout << a ;
 
}
 
int main()
{
 
unsigned int b;
int a;
 
 
 
y=3.4;
 
 
a1(y);
 
 
}
 
==
 
 
This will be accepted by C++ because the parameter a of a1() will equal
3, but this is "not" correct for "reliability" and it is not accepted by
Delphi and FreePascal and ADA because they are more strongly typed than
C++ and C and they will give an error that the type of the parameter a
of a1() is not the same as the type of y.
 
 
Also Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking and don't have many Run-time
checks etc. so that's not good in C++ and C because it is not good for
reliability and it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
And about Escher C++ Verifier, read carefully:
 
"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."
 
Read here:
 
http://www.eschertech.com/products/index.php
 
 
So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again that C++ and C don't have range checking and many
Run-time checks, so that's not good in C++ and C because it is not good
for reliability and it is not good for safety-critical systems.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 07:56PM -0400

Hello,
 
 
Delphi is much more rapid/RAD development solution than C++ and the
horror that was MFC. Delphi VCL was also more complete than what Visual
Basic,on the other hand with the new Delphi LLVM compilers there is a
promise for more platforms and better low-level performance,
 
Here is the new LLVM-based Delphi compilers:
 
http://docwiki.embarcadero.com/RADStudio/Tokyo/en/LLVM-based_Delphi_Compilers
 
 
I think i will also continu to work more with Delphi and FreePascal and
Lazarus, all of them use a "modern" Object Pascal that is much more
powerful than pascal, you have to look at the new Delphi language that
is powerful, i am also using the Delphi mode with FreePascal to be
compatible with Delphi.
 
Delphi for example works on the following platforms:
 
Windows
Linux
macOS
iOS
Android
 
You have to look at the new Delphi here, it is very powerful:
 
https://www.embarcadero.com/products/delphi
 
 
Lazarus and FreePascal are very interesting to use, you have to look
at Lazarus here to notice it:
 
https://www.lazarus-ide.org/
 
 
What i love in Delphi and FreePascal is that
Delphi and FreePascal like ADA are more strongly typed C++ or C and they
come with range checking and Run-time checks that catch conversion from
negative signed to unsigned , and catch out-of-bounds indices of dynamic
and static arrays and catch arithmetic overflow etc. and you can also
dynamically catch this exception of ERangeError etc. and that's good for
reliability.
 
But C++ and C don't have range checking and many Run-time checks etc. so
that's not good in C++ and C and that's not good for reliability and it
is not good for safety-critical systems.
 
 
This is why i will also to continu to work more with Delphi and
FreePascal and Lazarus, and my Delphi projects can be used with C++Builder.
 
Look for example at my last invention , here is my last invention for
Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
You can find my other "inventions"(that are my scalable algorithms etc.)
and my other projects here:
 
https://sites.google.com/site/aminer68/
 
Also you can improve strict-type safety(and thus reliability) in Delphi
and FreePascal with variants like this:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
I think C++ and C have many problems because they are "too" weakly
typed, here is another problem of C++ and C, look at this C++ example:
 
 
===
 
#include <conio.h>
#include <iostream>
using namespace std;
#include <stdint.h>
 
 
 
double y;
 
 
void a1(unsigned int a)
{
cout << a ;
 
}
 
int main()
{
 
unsigned int b;
int a;
 
 
 
y=3.4;
 
 
a1(y);
 
 
}
 
==
 
 
This will be accepted by C++ because the parameter a of a1() will equal
3, but this is "not" correct for "reliability" and it is not accepted by
Delphi and FreePascal and ADA because they are more strongly typed than
C++ and C and they will give an error that the type of the parameter a
of a1() is not the same as the type of y.
 
 
Also Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking and don't have many Run-time
checks etc. so that's not good in C++ and C because it is not good for
reliability and it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
And about Escher C++ Verifier, read carefully:
 
"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."
 
Read here:
 
http://www.eschertech.com/products/index.php
 
 
So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again that C++ and C don't have range checking and many
Run-time checks, so that's not good in C++ and C because it is not good
for reliability and it is not good for safety-critical systems.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 07:23PM -0400

Hello..
 
My following Delphi and FreePascal projects were updated, the FPU
exceptions were enabled in them:
 
Scalable Parallel implementation of Conjugate Gradient Dense Linear
System Solver library that is NUMA-aware and cache-aware, version 1.71
 
https://sites.google.com/site/aminer68/scalable-parallel-implementation-of-conjugate-gradient-linear-system-solver-library-that-is-numa-aware-and-cache-aware
 
And:
 
Scalable parallel implementation of Conjugate Gradient Linear Sparse
System Solver library version 1.71
 
https://sites.google.com/site/aminer68/parallel-implementation-of-conjugate-gradient-sparse-linear-system-solver
 
 
 
Thank you,
Amien Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 07:06PM -0400

Hello..
 
 
I think C++ and C have many problems because they are "too" weakly
typed, here is another problem of C++ and C, look at this C++ example:
 
 
===
 
#include <conio.h>
#include <iostream>
using namespace std;
#include <stdint.h>
 
 
 
double y;
 
 
void a1(unsigned int a)
{
cout << a ;
 
}
 
int main()
{
 
unsigned int b;
int a;
 
 
 
y=3.4;
 
 
a1(y);
 
 
}
 
==
 
 
This will be accepted by C++ because the parameter a of a1() will equal
3, but this is "not" correct for "reliability" and it is not accepted by
Delphi and FreePascal and ADA because they are more strongly typed than
C++ and C and they will give an error that the type of the parameter a
of a1() is not the same as the type of y.
 
 
Also Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking and don't many Run-time checks
etc. so that's not good in C++ and C because it is not good for
reliability and it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
And about Escher C++ Verifier, read carefully:
 
"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."
 
Read here:
 
http://www.eschertech.com/products/index.php
 
 
So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again that C++ and C don't have range checking and many
Run-time checks, so that's not good in C++ and C because it is not good
for reliability and it is not good for safety-critical systems.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 06:04PM -0400

Hello...
 
My following projects were updated, the FPU exceptions were enabled in them:
 
Scalable Parallel implementation of Conjugate Gradient Dense Linear
System Solver library that is NUMA-aware and cache-aware, version 1.71
 
https://sites.google.com/site/aminer68/scalable-parallel-implementation-of-conjugate-gradient-linear-system-solver-library-that-is-numa-aware-and-cache-aware
 
And:
 
Scalable parallel implementation of Conjugate Gradient Linear Sparse
System Solver library version 1.71
 
https://sites.google.com/site/aminer68/parallel-implementation-of-conjugate-gradient-sparse-linear-system-solver
 
 
 
Thank you,
Amien Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 20 05:49PM -0400

Hello..
 
 
My Scalable Parallel C++ Conjugate Gradient Linear System Solver Library
was updated to version 1.71, now the FPU exceptions were enabled,
and this version is much more stable and scalable and very fast.
 
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. .
 
Author: Amine Moulay Ramdane
 
Description:
 
This library contains a Scalable Parallel implementation of
Conjugate Gradient Dense Linear System Solver library that is
NUMA-aware and cache-aware, and it contains also a Scalable
Parallel implementation of Conjugate Gradient Sparse Linear
System Solver library that is cache-aware.
 
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.
 
 
You can download it from:
 
https://sites.google.com/site/aminer68/scalable-parallel-c-conjugate-gradient-linear-system-solver-library
 
Please download the zip file and read the readme file inside the
zip to know how to use it.
 
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.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.programming.threads+unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)