Petite librairie mathématique

Soyez le premier à donner votre avis sur cette source.

Vue 8 219 fois - Téléchargée 439 fois

Description

Bonjour à tous,
Voici une nouvelle source sans prétention aucune. Je me suis aperçu qu'il y avait peu de code dans la rubrique math et algorithme. Alors voici une classe avec quelques fonction utiles pour ceux qui ont besoin de math dans leur développement. Elle n'est pas excessivement fournie mais j'en rajoute au grès de mes besoins. Elle sera donc amenée à évoluer dans le futur.

J'ai déjà testé quelques unes des fonctions et cela marche bien. Je ne poste pas mon projet de test, un simple projet console suffira pour tester en ajoutant la dll générée comme référence à votre projet console.

En espérant que cela puisse aider certains d'entre vous. N'hésiter pas à critiquer, proposer, complimenter etc...

Source / Exemple :


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MathUtils
{
    /// <summary>
    /// Classe contenant diverses methodes mathématiques utiles.
    /// </summary>
    public static class MyMathUtils
    {
        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs Int32.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static Int32 Moyenne(Int32[] iTab)
        {
            Int32 iMoy = 0;
            
            try
            {
                for (int i = 0; i < iTab.Length; i++)
                {
                    iMoy += iTab[i];
                }
                iMoy /= iTab.Length;
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return iMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs Int16.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static Int16 Moyenne(Int16[] iTab)
        {
            Int16 iMoy = 0;

            try
            {
                for (int i = 0; i < iTab.Length; i++)
                {
                    iMoy += iTab[i];
                }
                iMoy /= Convert.ToInt16(iTab.Length);
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return iMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs Int64.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static Int64 Moyenne(Int64[] iTab)
        {
            Int64 iMoy = 0;

            try
            {
                for (int i = 0; i < iTab.Length; i++)
                {
                    iMoy += iTab[i];
                }
                iMoy /= iTab.Length;
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return iMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs float.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static float Moyenne(float[] fTab)
        {
            float fMoy = 0;
            
            try
            {
                for (int i = 0; i < fTab.Length; i++)
                {
                    fMoy += fTab[i];
                }
                fMoy /= fTab.Length;
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return fMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs double.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static double Moyenne(double[] dTab)
        {
            double dMoy = 0;

            try
            {
                for (int i = 0; i < dTab.Length; i++)
                {
                    dMoy += dTab[i];
                }
                dMoy /= dTab.Length;
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return dMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs decimale.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static decimal Moyenne(decimal[] decTab)
        {
            decimal decMoy = 0;

            try
            {
                for (int i = 0; i < decTab.Length; i++)
                {
                    decMoy += decTab[i];
                }
                decMoy /= decTab.Length;
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return decMoy;
        }

        /// <summary>
        /// Calcul de la moyenne d'un tableau de valeurs byte.
        /// </summary>
        /// <param name=iTab>Tableau de valeurs dont on veut calculer la moyenne.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>Retourne la valeur moyenne.</returns>
        public static byte Moyenne(byte[] byteTab)
        {
            byte bMoy = 0;

            try
            {
                for (int i = 0; i < byteTab.Length; i++)
                {
                    bMoy += byteTab[i];
                }
                bMoy /= Convert.ToByte(byteTab.Length);
            }
            catch (DivideByZeroException dbzException)
            {
                throw (dbzException);
            }
            return bMoy;
        }

        /// <summary>
        /// Fonctions de comparaison. Vérifie si une valeur est contenue dans
        /// l'espace définit par la précision
        /// </summary>
        /// <param name=dRef>Valeur de référence.</param>
        /// <param name=dVal>Valeur à tester.</param>
        /// <param name=dPrecision>Pourcentage de précision.</param>
        /// <returns>
        /// Retourne :
        ///     - 0 si dVal est dans la plage.
        ///     - inférieur à 0 si dVal est plus petit
        ///     - supérieur à 0 si dVal est plus grand
        /// </returns>
        public static int Compare(double dRef, double dVal, double dPrecision)
        {
            double dEcart = 0.0;
            double dMin   = 0.0;
            double dMax   = 0.0;
            dEcart = dRef * dPrecision;
            dMin   = dRef - dEcart;
            dMax   = dRef + dEcart;

            int iCompare;

            if ((dVal >= dMin) & (dVal <= dMax))
                iCompare = 0;
            else
            {
                if (dVal < dRef)
                    iCompare = -1;
                else
                    iCompare = 1;
            }
            return iCompare;
        }

        /// <summary>
        /// Correlation d'une courbe et d'une fonction rectangle
        /// </summary>
        /// <param name=iNbVal>nombre total de cases du tableau iTab.</param>
        /// <param name=iLargeurRectangle>largeur de la fonction rectangle.</param>
        /// <param name=iTab>tableau des valeurs de la fonction a convoluer.</param>
        /// <param name=dTabResultat>tableau contenant le produit de convolution de tab et de la fonction rectangle.</param>
        /// <returns>valeur maximum du tableau en entrée</returns>
        public static int CorrelCourbeFcnRect(int iLargeurRectangle, Int16[] iTab, double[] dTabResultat)
        {
            // Valeur max
            int iNmax = 0;

            // Initialisation de la case limite
            dTabResultat[iLargeurRectangle / 2] = 0.0;

            // calcul de la convolution
            for (int i = iLargeurRectangle / 2 + 1; i < (iTab.Length - iLargeurRectangle / 2 - 1); i++)
            {
                // Recherche valeur maximum du tableau tab
                iNmax = System.Math.Max(iNmax, iTab[i]);

                // valeur intermediaire
                double dVal = 0;

                for (int j = i - iLargeurRectangle / 2; j <= i + iLargeurRectangle / 2; j++)
                {
                    dVal += iTab[j];
                }
                dTabResultat[i] = dVal / Convert.ToDouble(iLargeurRectangle);
            }
            return (iNmax);
        }

        /// <summary>
        /// Calcul l'écart type des valeurs d'un tableau de double
        /// </summary>
        /// <param name=dTab>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur de l'écart type</returns>
        public static double EcartType(double[] dTab)
        {
            double dSommeCarree = 0.0;
            double dSomme = 0.0;
            double dMoyenne = 0.0;
            double dEcartType = 0.0;

            if (dTab.Length > 1)
            {
                for (int i = 0; i < dTab.Length; i++)
                {
                    dSomme += dTab[i];
                    dSommeCarree += (dTab[i] * dTab[i]);
                }
                dMoyenne = dSomme / dTab.Length;

                dEcartType = System.Math.Sqrt(((dTab.Length * dSommeCarree) - (dSomme * dSomme)) / (dTab.Length * (dTab.Length - 1)));
            }
            return dEcartType;
        }

        /// <summary>
        /// Calcul l'écart type des valeurs d'un tableau de Int16
        /// </summary>
        /// <param name=dTab>Tableau d'entier signé sur 16 octets.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur de l'écart type</returns>
        public static double EcartType(Int16[] iTab)
        {
            double dSommeCarree = 0.0;
            double dSomme = 0.0;
            double dMoyenne = 0.0;
            double dEcartType = 0.0;

            if (iTab.Length > 1)
            {
                for (int i = 0; i < iTab.Length; i++)
                {
                    dSomme += iTab[i];
                    dSommeCarree += (iTab[i] * iTab[i]);
                }
                dMoyenne = dSomme / iTab.Length;

                dEcartType = System.Math.Sqrt(((iTab.Length * dSommeCarree) - (dSomme * dSomme)) / (iTab.Length * (iTab.Length - 1)));
            }
            return dEcartType;
        }

        /// <summary>
        /// Calcul l'écart type résiduel des valeurs de tableaux de double.
        /// Cette méthode utilise la méthode définie plus bas : Correlation
        /// </summary>
        /// <param name=dTabX>Tableau de double.</param>
        /// <param name=dTabY>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur du résidu entre écart type</returns>
        public static double EcartTypeResiduel(double[] dTabX, double[] dTabY, int iNbVal)
        {
            double dErreur = 0;
            double dSigmaY = 0;
            double dResidu = 0;

            if (iNbVal > 1)
            {
                dSigmaY = MyMathUtils.EcartType(dTabY);
                dResidu = Correlation(dTabX, dTabY, iNbVal); 
                dErreur = dSigmaY * System.Math.Sqrt(1 - (dResidu * dResidu));
            }
            return dErreur;
        }

        /// <summary>
        /// Calcul la valeur médianne et la moyenne des valeurs d'un tableau de double.
        /// Pour la valeur médianne, on exclu les 10% valeurs basses et les 10% valeurs hautes
        /// Pour la moyenne, c'est la moyenne de tous les points.
        /// Cette méthode utilise également la fonction : OrdonneTableau
        /// </summary>
        /// <param name=dTab>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <param name=moyenne>Moyenne de tous les points.</param>
        /// <returns>valeur médiane et la moyenne par référence</returns>
        public static double Median(double[] dTab, double[] moyenne)
        {
            double dSommeMoyenne = 0.0;
            double dSommeMedian  = 0.0;
            int iNbPointsActifs  = 0;
            int iNbPointsAnnul   = 0;

            // Calcul 10% de iNbVal
            iNbPointsAnnul = Convert.ToInt32(dTab.Length * 0.1);
            iNbPointsActifs = dTab.Length - (2 * iNbPointsAnnul);

            // Ordonne les points dans le tableau dTab
            OrdonneTableau(dTab);

            for (int i = 0; i < dTab.Length; i++)
            {
                dSommeMoyenne += dTab[i];

                if ( (i >= iNbPointsAnnul) && (i < dTab.Length - iNbPointsAnnul) )
                {
                    dSommeMedian += dTab[i];
                }
                // Calcul les moyennes
                moyenne[i] = dSommeMoyenne / dTab.Length;
            }
            return dSommeMedian / (dTab.Length - (2 * iNbPointsAnnul));
        }

        /// <summary>
        /// Calcul la valeur médianne et la moyenne des valeurs d'un tableau de Int16.
        /// Pour la valeur médianne, on exclu les 10% valeurs basses et les 10% valeurs hautes
        /// Pour la moyenne, c'est la moyenne de tous les points.
        /// Cette méthode utilise également la fonction : OrdonneTableau
        /// </summary>
        /// <param name=iTab>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <param name=moyenne>Moyenne de tous les points.</param>
        /// <returns>valeur médiane.</returns>
        public static double Median(Int16[] iTab, double[] moyenne)
        {
            double dSommeMoyenne = 0.0;
            double dSommeMedian = 0.0;
            int iNbPointsActifs = 0;
            int iNbPointsAnnul = 0;

            // Calcul 10% de iNbVal
            iNbPointsAnnul = Convert.ToInt32(iTab.Length * 0.1);
            iNbPointsActifs = iTab.Length - (2 * iNbPointsAnnul);

            // Ordonne les points dans le tableau dTab
            OrdonneTableau(iTab);

            for (int i = 0; i < iTab.Length; i++)
            {
                dSommeMoyenne += iTab[i];

                if ((i >= iNbPointsAnnul) && (i < iTab.Length - iNbPointsAnnul))
                {
                    dSommeMedian += iTab[i];
                }
                // Calcule les moyennes
                moyenne[i] = dSommeMoyenne / iTab.Length;
            }
            return dSommeMedian / (iTab.Length - (2 * iNbPointsAnnul));
        }

        /// <summary>
        /// Ordonne un tableau de double par ordre croissant
        /// </summary>
        /// <param name=dTab>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        public static void OrdonneTableau(double[] dTab)
        {
            double dTemp = 0.0;

            // Ordonne les points dans le tableau tab
            for (int i = 0; i < dTab.Length; i++)
            {
                for (int j = i + 1; j < dTab.Length; j++)
                {
                    if (dTab[i] > dTab[j])
                    {
                        dTemp = dTab[i];
                        dTab[i] = dTab[j];
                        dTab[j] = dTemp;
                    }
                }
            }
         }

        /// <summary>
        /// Ordonne un tableau de Int16 par ordre croissant
        /// </summary>
        /// <param name=iTab>Tableau de Int16.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        public static void OrdonneTableau(Int16[] iTab)
        {
            Int16 iTemp = 0;

            // Ordonne les points dans le tableau tab
            for (int i = 0; i < iTab.Length; i++)
            {
                for (int j = i + 1; j < iTab.Length; j++)
                {
                    if (iTab[i] > iTab[j])
                    {
                        iTemp = iTab[i];
                        iTab[i] = iTab[j];
                        iTab[j] = iTemp;
                    }
                }
            }
         }

        // Ordonne deux tableaux de double selon l'ordre du premier en ordre croissant
        /// <summary>
        /// Ordonne 2 tableaux de double selon l'ordre du premier en ordre croissant
        /// </summary>
        /// <param name=dTab1>Premier tableau de double.</param>
        /// <param name=dTab2>Second tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        public static void Ordonne2Tableau(double[] dTab1, double[] dTab2, int iNbVal)
        {
            double dTemp = 0.0;

            // Ordonne les points dans les tableaux tab1 et tab2 selon l'ordre de tab1
            for (int i = 0; i < iNbVal; i++)
            {
                for (int j = i + 1; j < iNbVal; j++)
                {
                    if (dTab1[i] > dTab1[j])
                    {
                        dTemp = dTab1[i];
                        dTab1[i] = dTab1[j];
                        dTab1[j] = dTemp;
                        dTemp = dTab2[i];
                        dTab2[i] = dTab2[j];
                        dTab2[j] = dTemp;
                    }
                }
            }
        }

        /// <summary>
        /// Calcul de la variance d'un tableau de double
        /// </summary>
        /// <param name=dTab>Tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur de la variance</returns>
        public static double Variance(double[] dTab)
        {
            double dSomme = 0;
            double dSomme2 = 0;
            double dMoyenne = 0;
            double dVariance = 0;

            if (dTab.Length > 0)
            {
                for (int i = 0; i < dTab.Length; i++)
                {
                    dSomme += dTab[i];
                    dSomme2 += (dTab[i] * dTab[i]);
                }

                dMoyenne = dSomme / dTab.Length;
                dVariance = (dSomme2 / dTab.Length) - (dMoyenne * dMoyenne);
            }
            return dVariance;
        }

        /// <summary>
        /// Calcul de la covariance de 2 tableaux de double
        /// </summary>
        /// <param name=dTabX>Premier tableau de double.</param>
        /// <param name=dTabY>Second tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur de la covariance</returns>
        public static double CoVariance(double[] dTabX, double[] dTabY, int iNbVal)
        {
            double dSommeX = 0;
            double dMoyenneX = 0;
            double dSommeY = 0;
            double dMoyenneY = 0;
            double dSommeXY = 0;
            double dCoVariance = 0;

            if (iNbVal > 0)
            {
                for (int i = 0; i < iNbVal; i++)
                {
                    dSommeX += dTabX[i];
                    dSommeY += dTabY[i];
                    dSommeXY += (dTabX[i] * dTabY[i]);
                }

                dMoyenneX = dSommeX / iNbVal;
                dMoyenneY = dSommeY / iNbVal;
                dCoVariance = (dSommeXY / iNbVal) - (dMoyenneX * dMoyenneY);
            }
            return dCoVariance;
        }

        /// <summary>
        /// Calcul de la correlation entre 2 tableaux de double
        /// </summary>
        /// <param name=dTabX>Premier tableau de double.</param>
        /// <param name=dTabY>Second tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <returns>valeur de la correlation</returns>
        public static double Correlation(double[] dTabX, double[] dTabY, int iNbVal)
        {
            double dCorrelation = 0;

            if (iNbVal > 1)
                dCorrelation = CoVariance(dTabX, dTabY, iNbVal) / System.Math.Sqrt(MyMathUtils.Variance(dTabX) * MyMathUtils.Variance(dTabY));
            return dCorrelation;
        }

        /// <summary>
        /// Calcul de regression linéaire
        /// </summary>
        /// <param name=dTabX>Premier tableau de double.</param>
        /// <param name=dTabY>Second tableau de double.</param>
        /// <param name=iNbVal>Nombre de valeurs.</param>
        /// <param name=dA>Paramètre 1.</param>
        /// <param name=dB>Paramètre 1.</param>
        public static void RegLin(double[] dTabX, double[] dTabY, int iNbVal, double dA, double dB)
        {
            double dSommeXY = 0.0;
            double dSommeX  = 0.0;
            double dSommeY  = 0.0;
            double dSommeXCarree = 0.0;
            double dMoyenneX = 0.0;
            double dMoyenneY = 0.0;
            double dU, dV = 0.0;

            dA = 0.0;
            dB = 0.0;

            for (int i = 0; i < iNbVal; i++)
            {
                dSommeX += dTabX[i];
                dSommeY += dTabY[i];
                dSommeXY += (dTabX[i] * dTabY[i]);
                dSommeXCarree += (dTabX[i] * dTabX[i]);
            }

            dMoyenneX = dSommeX / iNbVal;
            dMoyenneY = dSommeY / iNbVal;

            dU = (1.0 / iNbVal) * dSommeXY;
            dV = (1.0 / iNbVal) * dSommeXCarree;

            if (dV != 0.0)
            {
                dA = (dU - (dMoyenneX * dMoyenneY)) / (dV - (dMoyenneX * dMoyenneX));
                dB = dMoyenneY - (dA * dMoyenneX);
            }
        }

        // Calcul de la largeur à n sigma d'un histogramme
        /// <summary>
        /// Calcul de la largeur à n sigma d'un histogramme
        /// </summary>
        /// <param name=iNbBarres>Nombre de barre de l'histogramme.</param>
        /// <param name=dTabNbEchantillon>Tableaux du nombre d'echantillon.</param>
        /// <param name=dTabValEchantillon>tableaux de valeurs de l'echantillon.</param>
        /// <param name=dCoef>Coefficient.</param>
        /// <returns>Valeur de la largeur demandée.</returns>
        public static double SigmaHistogramme(int iNbBarres, double[] dTabNbEchantillon, double[] dTabValEchantillon, double dCoef)
        {
            double dTemp = 0.0;
           
            // Calcul de la valeur moyenne des échantillons
            double dPopulation = 0.0;
            double dSomme = 0.0;
            
            for (int n = 0; n < iNbBarres; n++)
            {
                dSomme += (dTabNbEchantillon[n] * dTabValEchantillon[n]);
                dPopulation += dTabNbEchantillon[n];
            }
            
            double dValeurMoyenne = dSomme / dPopulation;

            // Calcul de la somme des (Xi-moy) au carré
            dSomme = 0.0;
            for (int n = 0; n < iNbBarres; n++)
            {
                dTemp = dTabValEchantillon[n] - dValeurMoyenne;
                dSomme += (dTabNbEchantillon[n] * dTemp * dTemp);
            }

            // Calcul de l'écart type
            dTemp = System.Math.Sqrt(dSomme);
            double dSigma = dTemp / dPopulation;

            // Retourne la largeur demandée
            return (dSigma * dCoef);
        }

        /// <summary>
        /// RechercheMax. On calcule par la methode des moindres carres la parabole
        /// de meilleur approximation de la courbe (abscisses[i],ordonnees[i]) et
        /// on en calcule la position et la valeur du sommet et on verifie
        /// que le sommet est dans l'intervalle de mesure .
        /// </summary>
        /// <param name=iNbPointCourbe>nombre de points de la courbe.</param>
        /// <param name=dTabX>abscisses de la courbe.</param>
        /// <param name=dTabY>ordonnees de la courbe.</param>
        /// <param name=dSommetX>position du sommet de la courbe.</param>
        /// <param name=dSommetY>valeur théorique du sommet de la courbe.</param>
        /// <returns>TRUE si OK sinon FALSE.</returns>
        public static bool RechercheMax(Int16 iNbPointCourbe, double[] dTabX, double[] dTabY, double dSommetX, double dSommetY)
        {
            // matrice des moindres carres
            double[,] dMatrice = new double[3, 4];
            
            // pivot de gauss de la resolution du systeme */
            double dPivot;
            
            // variables temporaires
            double dXTemp1;
            double dXTemp2;
            
            // incident (pas de solution FAUX)
            double dDet;
            
            // coefficients de la parabole
            double dCoeff1;
            double dCoeff2;
            double dCoeff3;
            
            // limites de l'intervalle de mesures
            double dXmin;
            double dXmax;
            
            // Initialisation de la matrice des moindres carres
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    dMatrice[i,j] = 0.0;
                }
            }
            
            // calcul des coefficients de la matrice de resolution
            dXmin = +1.7E+308;
            dXmax = -1.7E+308;
            for (int i = 0; i < iNbPointCourbe; i++)
            {
                dXmin = System.Math.Min(dXmin, dTabX[i]);
                dXmax = System.Math.Max(dXmax, dTabX[i]);
                dXTemp1 = dTabX[i] * dTabX[i];
                dMatrice[0,0] += dXTemp1 * dXTemp1;
                dMatrice[0,1] += dXTemp1 * dTabX[i];
                dMatrice[0,2] += dXTemp1;
                dMatrice[1,2] += dTabX[i];
                dMatrice[0,3] += dXTemp1 * dTabY[i];
                dMatrice[1,3] += dTabX[i] * dTabY[i];
                dMatrice[2,3] += dTabY[i];
                if (dTabX[i] != 0) dMatrice[2, 2]++;
            }
            dMatrice[1,0] = dMatrice[0,1];
            dMatrice[1,1] = dMatrice[2,0] = dMatrice[0,2];
            dMatrice[2,1] = dMatrice[1,2];
            
            // resolution du systeme lineaire par la methode du pivot
            for (int i = 0; i < 3; i++)
            {
                for (int k = i; dMatrice[k, i] == 0 && k <= 3; k++)
                {
                    if ((dPivot = dMatrice[k, i]) == 0)
                    {
                        dDet = 0;
                        break;
                    }
                    for (int j = 0; j <= 3; j++)
                    {
                        dXTemp2 = dMatrice[k, j] / dPivot;
                        dMatrice[k, j] = dMatrice[i, j];
                        dMatrice[i, j] = dXTemp2;
                    }
                }
                for (int k = 0; k < 3; k++)
                {
                    if (k != i)
                    {
                        for (int j = 3; j >= i; j--)
                        {
                            dMatrice[k, j] -= dMatrice[i, j] * dMatrice[k, i];
                        }
                    }
                }
            }
            
            // coefficient de la parabole d'approximation
            dCoeff1 = dMatrice[0, 3];
            dCoeff2 = dMatrice[1, 3];
            dCoeff3 = dMatrice[2, 3];
            
            // sommet de la parabole
            dSommetX = -dCoeff2 / 2 / dCoeff1;
            dSommetY = dCoeff1 * (dSommetX) * (dSommetX) + dCoeff2 * (dSommetX) + dCoeff3;
            
            // test si on est dans l'intervalle de mesure
            bool bIncident = false;
            if ((dSommetX < dXmin) || (dSommetX > dXmin))
                bIncident = true;
            return (bIncident);
        } 
    }
}

Conclusion :


Une source qui peut permettre de comprendre comment faire une dll en c#.Net et comment l'utiliser

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
10
Date d'inscription
lundi 26 mars 2007
Statut
Membre
Dernière intervention
17 janvier 2011

Tu peux aussi utilisé le mot clé "dynamic" qui te donnera une et une seul fonction de Moyenne car une moyenne n'est rien de plus qu'une boulce ou tu additionne le tout puis divisant le tout par le nombre d'élément, il n'y a pas de problème de type.

Le mot clé "dynamic" est un équivalent au mot clé "var" à la différence près que "var" est évalué par Visual Studio afin de simplifié la rédaction de code et te permet d'avoir l’auto-complétion d'intelisense, hors "dynamic" sera évalué à l'exécution.

Mais pour une programmation rigoureuse , je te conseil en plus d'utiliser des "if(myojb is Int[])","if(myojb is Float[])", etc... pour vérifier que se sont bien des données numérique (entières ou réelles) qui te sont passé.

Celà te donne UNE seule fonction utilisable avec tout ce que tu veut! (exemple si tu surcharge les opérateurs "+" et "/" d'une classe personnelle, il te suffira de rajouter un condition de test "if(myobj is Myclass[])" etc... enfin quelque choses dans ce genre je te laisse voir la documentation sur le MSDN pour de plus ample informations.

dynamic :
http://msdn.microsoft.com/fr-fr/library/dd264741.aspx

var :
http://msdn.microsoft.com/fr-fr/library/bb383973.aspx

Sinon ça reste une source intéressante.
Messages postés
6063
Date d'inscription
dimanche 13 avril 2003
Statut
Modérateur
Dernière intervention
15 juillet 2011
28
NB : les templates ne fonctionne pas pour ce type d'exemple.

Exemple

T dTemp = 0;
Ne fonctionne pas car T doit etre un int dans ce cas !

Les templates c'est plus pour des classes que des type de base
Messages postés
642
Date d'inscription
mercredi 10 septembre 2008
Statut
Membre
Dernière intervention
9 février 2017
6
Ah oui excellente idée. Ça va me permettre de voir les templates par la même occasion.
Je fais ça dès que j'ai un moment.

Merci pour la suggestion

@pluche

SD
Messages postés
23
Date d'inscription
mardi 24 octobre 2006
Statut
Membre
Dernière intervention
23 février 2011

Belel initiative, Mais je te conseillerai d'utiliser les templates pour les fonctions qui font le même traitement sur le même nombre de paramètres comme Moyenne par exemple.

@+
Messages postés
642
Date d'inscription
mercredi 10 septembre 2008
Statut
Membre
Dernière intervention
9 février 2017
6
Ah d'accord. En fait c'est une de mes habitudes de programmation.
Ca me permet de voir dans mes sources quel type de données je gère.

Mais merci pour la remarque. Autant faire les choses de façon conventionnelle

@pluche

SD
Afficher les 8 commentaires

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.