Quantum bibliothèque mathématiques

Soyez le premier à donner votre avis sur cette source.

Vue 9 277 fois - Téléchargée 1 737 fois

Description

Quantum est une librairie de calculs mathématiques, physiques et chimiques.

On peut également retrouvé les caractéristiques de tout les éléments du tableau périodique ou encore faire des calculs a l'aide de fonction spéciale.

Ceci est le début de la DLL je mettrai les versions futures lors d'une prochaine mise à jour.

Source / Exemple :


public class EquationsDifférentielles
    {
        private static readonly double[] X = new double[100];

        private static readonly double[] Y = new double[100];

        // y'= Fonction(x,y)
        public delegate double Fonction(double x, double y);

        public static double EulerRomberg(int nombreIteration,double pas,double erreurRelative,double x0,double y0,Fonction fonction)
        {
            var t = new double[20];
            // conditions initiales
            X[0] = x0;
            Y[0] = y0;

            // Integration
            int k = 0;
            for (int n = 0; n <= nombreIteration; n++)
            {
                double a = X[n];
                double b = Y[n];
                t[1] = Y[n] + pas*fonction(a, b);
                int l = 1;
                int lm = 2;

                double z;
                do
                {
                    a = X[n];
                    b = Y[n];
                    for (int j = 1; j <= lm; j++)
                    {
                        a = a + pas/lm;
                        b = b + pas/lm*fonction(a, b);
                    }
                    t[l + 1] = b;
                    
                    k = l;
                    int mm = 2;
                    z = 1.0;

                    if(k>1)
                        do
                        {
                            t[k] = (mm*t[k + 1] - t[k])/(mm - 1);
                            z = Math.Abs(t[k] - t[k - 1]);
                            
                            k--;
                            mm *= 2;
                        } while (z>=erreurRelative&&k>1);
                    if(k==1)
                    {
                        l++;
                        lm *= 2;
                    }
                } while (l<10&&z>=erreurRelative);
                Y[n + 1] = t[k];
               
            }

            return t[k];
        }
    }
}

Conclusion :


Tout le monde peut ajouter son grain de sel mais merci de me prévenir avant.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
2
Date d'inscription
jeudi 16 décembre 2010
Statut
Membre
Dernière intervention
1 septembre 2011

Tiens ça m'intéresse !

Comment comptes-tu implémenter des calculs quantiques ? Je crois qu'il faudrait d'abord implémenter deux classes de maths très importantes avant le quantique proprement dit :

1) la résolution des équations différentielles (au moins jusqu'au 2ème ordre) par l'une des méthodes de ton choix : eurler, prédiction-correction, runge-kutta etc.
2) l'algèbre des matrices : addition, multiplication, inverse, diagonalisation, gauss-jordan etc.

Je dispose d'un peu de temps pour t'aider si tu le souhaites !

D'ailleurs tu m'as devancé car j'ai moi aussi commencé une bibliothèque de maths... mais je suis lent, donc elle contient que trop peu de chose pour le moment.

Un truc qui te manque, en arithmétique : la décomposition en facteurs premiers ! Voici mon bout de code :

1) une méthode PremierFacteur qui calcule le prochain facteur premier de n au moins égal à d
Ex: si n = 17 et d=11 alors PremierFacteur(17, 11)=13.

#region méthode PremierFacteur
public static long PremierFacteur(long n, long d)
{
// Cette méthode détermine le prochain facteur premier de n au moins égal à d
while (n % d != 0)
{
if (d == 2)
{
d = 3;
}
else
{
d += 2;
}
}

return d;
}
#endregion //

2) une méthode EstPremier qui renvoit un bool si n est premier :

#region méthode EstPremier
public static bool EstPremier(long n)
{
// Cette méthode rend true si n est premier, false sinon.
bool res = false;

if (PremierFacteur(n, 2) == n)
{
res = true;
}

return res;
}
#endregion

3) enfin, la méthode Decomposition, qui décompose un nombre en produit de ses facteurs premiers :Ex : si n 5445 alors Decomposition(5445) 3*3*5*11*11

#region méthode Decomposition
public static void Decomposition(long n)
{
// Décomposition d'un entier naturel en produit de facteurs premiers

long d = PremierFacteur(n, 2);

if (n == d)
{
Console.WriteLine("{0} est premier !", n);
}
else
{
Console.Write("{0} = {1}", n, d);
do
{
n = n / d;
d = PremierFacteur(n, d);
Console.Write(" x {0}", d);
} while (d != n);

}
}
#endregion

Voilà, donc si jamais tu apprécies ma manière de coder, et si tu veux de l'aide, envoie moi un mp ! @++
Messages postés
2
Date d'inscription
dimanche 28 août 2011
Statut
Membre
Dernière intervention
1 septembre 2011

Slt, FRENCHEM67

Pour ce qui concerne la physique quantique elle est en cours d'implémentation. Je sais qu'il y'a énormement de travail si je veux tout faire.

En ce qui concerne les commentaires c'est que le fichier poster est un autre fichier que l'original et donc je n'est pas mis les commentaires je les mettrais dans les prochaines version.

Pour les Exceptions je sais pas si il faut les laisser ou pas à voir comme tu dis je regarderais sa plus tard. Si quelqu'un à un avis sur la question qu'il n'hesite surtout pas.
Messages postés
2
Date d'inscription
jeudi 16 décembre 2010
Statut
Membre
Dernière intervention
1 septembre 2011

Salut QuantumNET,

Tout d'abord en voyant le titre de ta source, je pensais avoir affaire à une bibliothèque permettant des calculs de physique quantique ! Et non... Ce sont des classes de maths pures, physique (optique géométrique) et chimie (la table des éléments). Je vois donc que tu aimerais être assez exhaustif. Or, à mon avis tu ne pourras pas ! Du coup je te conseille donc de spécialiser ta DLL dans l'un des trois domaines où, tu verras, tu auras déjà beaucoup beaucoup de boulot pour la compléter.

D'un point de vue code, c'est pas mal. Mais il manque des commentaires par -ci par-là et j'ai vu que tu utilisais des Exceptions pour faire du contrôle de saisie utilisateur (dans la classe NombresPremiers) or je sais pas si cela est vraiment pertinent d'arrêter le programme quand l'utilisateur rentre une mauvaise valeur... A voir !
Messages postés
2
Date d'inscription
dimanche 28 août 2011
Statut
Membre
Dernière intervention
1 septembre 2011

Merci pour la remarque je modifie mon code tout de suite
Messages postés
473
Date d'inscription
mercredi 7 août 2002
Statut
Membre
Dernière intervention
10 juin 2015

J'ai commencé à éplucher un peu ton code.
Le seul point sur lequel je trouve à redire est ta gestion des éléments chimiques.
Je considère plutôt les descriptions comme des données et non comme des programmes. Je pense donc que tu devrais inclure les descriptions dans des ressources de ton programme.

Dans l'exponentielle rapide, tu peux remplacer m b / 2 par m b >> 1 (décallage de bit à droite)
et if (b > 2*m) par if (b & 1 == 1)
qui est plus rapide et cohérent d'un point de vue mathématique, puisqu'il s'agit d'un algorithme bit à bit.

Le reste à l'air plutôt assez interressant.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.