Petite librairie mathématique
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...
Une source qui peut permettre de comprendre comment faire une dll en c#.Net et comment l'utiliser
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
- Petite librairie mathématique
- Pointeuse pour petite entreprise - Forum Python
- Difference entre librairie et bibliotheque ✓ - Forum C / C++ / C++.NET
- Inserer et utiliser une librairie - Forum C / C++ / C++.NET
- Différence entre librairie et bibliothèque - Forum C
- Méthode mathématique pour gagner au keno - Forum PHP
Du même auteur (dodo7263)
-
Astre (ASTronomy REport) V00.01
-
Retrouver la clé d'activation windows base de registre
-
Verifier votre code rio (releve identifiant operateur) pour la portabilité de votre numéro de portable
-
Fontasy : classe de manipulation de chaine de caractère
-
Gestionnaire des todo dissemines un peu partout dans vos codes...
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.