Bibliotheque mathematique

Télécharger le projet
Commenter

Description

C'est une simple petite bibliotheque mathematiques censee, a long terme, remplacer math.h, pour le moment elle ne gere que les operations simple, mais je compte implementer les logarihmes et les fonctions statistiques bientot.
Pour le moment elle peut servir a ceux qui font une calculette basique.

Source / Exemple : 


//PI
#define PI 3.141592

//Fonctions sur les Degres Celsius Farenheit et Kelvin
double CelsiusToFarenheit(double Celsius)
{
	double Farenheit = 32 + 1.8 * Celsius;
	return Farenheit;
}

double CelsiusToKelvin(double Celsius)
{
	double Kelvin = Celsius + 273.15;
	return Kelvin;
}

double FarenheitToCelsius(double Farenheit)
{
	double Celsius = (32 - Farenheit) / (- 1.8);
	return Celsius;
}

double KelvinToCelsius(double Kelvin)
{
	double Celsius = Kelvin - 273.15;
	return Celsius;
}

double KelvinToFarenheit(double Kelvin)
{
	double Farenheit = 32 + 1.8 * (Kelvin - 273.15);
	return Farenheit;
}

//fonctions sur les Radians et les centigrades
double DegreToRadian(double Degre)
{
	double Radian = (Degre * PI) / 180;
	return Radian;
}

double RadianToDegre(double Radian)
{
	double Degre = (Radian * 180) / PI;
	return Degre;
}

//fonctions sur les aires
double AireCarre(double cote)
{
	double Aire = cote * cote;
	return Aire;
}

double AireRectangle(double longueur, double largeur)
{
	double Aire = longueur * largeur;
	return Aire;
}

double AireTriangle(double base, double hauteur)
{
	double Aire = (base * hauteur) / 2;
	return Aire;
}

double AireParallelogramme(double base, double hauteur)
{
	double Aire = (base * hauteur);
	return Aire;
}

double AireLosange(double gdediag, double ptediag)
{
	double Aire = (gdediag * ptediag) / 2;
	return Aire;
}

double AireTrapeze(double ptebase, double gdebase, double hauteur)
{
	double Aire = ((ptebase + gdebase) * hauteur) / 2;
	return Aire;
}

double AireCercle(double rayon)
{
	double Aire = PI * rayon * rayon;
	return Aire;
}

//fonctions sur les volumes
double VolumeSphere(double rayon)
{
	double Volume = (4 * PI * rayon * rayon * rayon)/3;
	return Volume;
}

double VolumePave(double longueur, double largeur, double hauteur)
{
	double Volume = longueur * largeur * hauteur;
	return Volume;
}

double VolumeCylindre(double rayon, double hauteur)
{
	double Volume = (PI * rayon * rayon) * hauteur;
	return Volume;
}

double VolumePyramide(double cote, double hauteur)
{
	double Volume = (cote * cote * hauteur) * 1/3;
	return Volume;
}

double VolumeCone(double rayon, double hauteur)
{
	double Volume = (rayon * rayon * hauteur) * 1/3;
	return Volume;
}

//diverses fonctions mathematiques	 

//PGCD
double PGCD(double a, double b)
{
    double iRev;
    
    while(a != b)
    {
        if(a < b)
        {
            iRev = a;
            a = b;
            b = iRev;
        }
        a = a - b;
    }
    return a;
}

//Nombres Premiers
bool NombrePremier(int valeur)
{
	int diviseur = 2;
	int test = 0;

	while(diviseur < valeur-1)
	{
		if(valeur % diviseur == 0)   test++;
     	diviseur++;
	}
	
	if(test==0)	return true;
	else return false;
}

//Valeur Absolue
double ValeurAbsolue(double valeur)
{
	if(valeur < 0) valeur = - valeur;
	else valeur = valeur;
	return valeur;
}

//Identites Remarquables
double IdentiteRemarquable1(double a, double b)
{
	double IR = a*a + 2*a*b + b*b;
	return IR;
}

double IdentiteRemarquable2(double a, double b)
{
	double IR = a*a - 2*a*b + b*b;
	return IR;
}

double IdentiteRemarquable3(double a, double b)
{
	double IR = a*a - b*b;
	return IR;
}

//Theoreme de Pythagore	
double Pythagore(double cote1, double cote2)
{
	double Hypotenuse = cote1*cote1 + cote2*cote2;
	return Hypotenuse;
}

//racines carrees et cubiques
double RacineCarree(double valeur)
{
	double racine = 1;
		
	for(int i = 0; i < 10; i++)
		racine = (valeur/racine + racine) / 2;
		return racine;
}

double RacineCubique(double valeur)
{
	double racine = 1;
	
	for(int i =0; i < 10; i++)	racine = (valeur/racine + racine) / 3;
	return racine;
}

//reciproque du theoreme de Pythagore	
double ReciproquePythagore(double cote, double Hypotenuse)
{
	  double cote2 = RacineCarree((Hypotenuse*Hypotenuse) - (cote*cote));
	  return cote2;	
}

//carres, cubes
double Carre(double valeur)
{
	double carre = valeur * valeur;
	return carre;
}

double Cube(double valeur)
{
	double cube = valeur * valeur * valeur;
	return cube;
}

//Puissances
double Puissance(double nombre, double exposant)
{
	double Resultat;
	for(int i = 0; i <= exposant; i++)		
	{
		Resultat = nombre * nombre;
		Resultat = Resultat * nombre;
	}
	return Resultat/nombre;
}
	
//de 10
double PuissanceDix(double nombre, double exposant)
{
	double Resultat;
	for(int i=0; i<=exposant; i++)	
	{
		if( i == 1)	Resultat = 10*10;
		else Resultat = Resultat * 10;
	}
	return (Resultat*nombre/10);
}

Conclusion :


Bon c'est pas le code le plus propre que j'ai fait (normal je l'ai fait vite fait (ca fait beaucoup de fait tout ca)).
Des ameliorations des que j'ai du temps a moi.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.