#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
#include"complexe.h"
#include"linkedList.h"
/*------------------------------------------*/
/*
Retourne la partie reelle
*/
double reComplexe(complexe c)
{
return c.re;
}
/*------------------------------------------*/
/*
Retourne la partie imaginaire
*/
double imComplexe(complexe c)
{
return c.im;
}
/*------------------------------------------*/
/*
Retourne le module
*/
double modComplexe(complexe c)
{
return c.mod;
}
/*------------------------------------------*/
/*
Retourne l'argument
*/
double argComplexe(complexe c)
{
return c.arg;
}
/*------------------------------------------*/
/*
Affiche c sous forme exponentielle
*/
void printExpComplexe(complexe c)
{
printf("%.10lfe^(%.10lfi)", c.mod, c.arg);
}
/*------------------------------------------*/
/*
Affiche l'affixe de c
*/
void printAffComplexe(complexe c)
{
printf("(%.10lf + %.10lfi)", c.re, c.im);
}
/*------------------------------------------*/
/*
Cree un complexe a partir de son affixe
*/
complexe makeAffComplexe(double re, double im)
{
complexe c = {re, im, sqrt(re*re + im*im), 0.0};
if (c.mod != 0.0)
{
c.arg = acos(c.re/c.mod) * ((c.im >= 0 )? 1 : - 1) ;
}
return c;
}
/*------------------------------------------*/
/*
Cree un complexe a partir de sa forme exponentielle
*/
complexe makeExpComplexe(double mod, double arg)
{
complexe c = {0.0, 0.0, mod, arg};
c.arg += M_PI;
long l = c.arg/(2.*M_PI);
c.arg -= l*2.*M_PI;
c.arg -= M_PI;
if (mod != 0.0)
{
c.re = c.mod * cos(c.arg);
c.im = c.mod * sin(c.arg);
}
return c;
}
/*------------------------------------------*/
pComplexe copyComplexe(complexe c)
{
pComplexe p = (pComplexe)malloc(sizeof(complexe));
if (p == NULL)
exit(0);
p->re = c.re;
p->im = c.im;
p->mod = c.mod;
p->arg = c.arg;
return p;
}
/*------------------------------------------*/
/*
Retourne le conjugue de c
*/
complexe conjugueComplexe(complexe c)
{
return makeAffComplexe(c.re, -c.im);
}
/*------------------------------------------*/
/*
Soustrait c1 et c2
*/
complexe subComplexe(complexe c1, complexe c2)
{
return makeAffComplexe(c1.re - c2.re, c1.im - c2.im);
}
/*------------------------------------------*/
/*
Additionne c1 et c2
*/
complexe addComplexe(complexe c1, complexe c2)
{
return makeAffComplexe(c1.re + c2.re, c1.im + c2.im);
}
/*------------------------------------------*/
/*
Multiplie c1 et c2
*/
complexe multComplexe(complexe c1, complexe c2)
{
return makeAffComplexe(c1.re * c2.re - c1.im * c2.im,
c1.re * c2.im + c1.im * c2.re);
}
/*------------------------------------------*/
/*
Multiplie c par le reel d
*/
complexe multReelComplexe(double d, complexe c)
{
return makeExpComplexe(d * c.mod, c.arg);
}
/*------------------------------------------*/
/*
Divise c2 par c1
*/
complexe divComplexe(complexe c1, complexe c2)
{
return makeExpComplexe(c1.mod / c2.mod, c1.arg - c2.arg);
}
/*------------------------------------------*/
/*
Eleve c a la puissane n
*/
complexe puissComplexe(complexe c, unsigned long n)
{
return makeExpComplexe(pow(c.mod, n), n*c.arg);
}