void trapezes(double n)
{
double a = 0;
double b = 5000;
double i = 1;
double h = (b - a) / 10000;
double result = 0;
while (i < b)
{
result = result + produit(n, (a + i * h));
i = i + 1;
}
result = ((result * 2) + produit(n, a) + produit(n, b)) * ((b - a) / 20000);
prompt(result, result - (M_PI / 2), n, 2);
}
/** DEBUT BIGINT factorielle(BIGINT, INT); DEBUT **/
BIGINT factorielle(unsigned int nb) {
BIGINT tmp, tmp2, tmp3;
BIGINT p = chaine2liste("1");
BIGINT r = chaine2liste("1");
int h = 0, shift = 0, high = 1;
unsigned int y = nb;
initListe(&tmp);
initListe(&tmp2);
initListe(&tmp3);
if (nb < 2) return chaine2liste("1");
N = 1;
int log2n = -1;
/// Equivaut à log2(n) ///
while (y) {
y >>= 1;
log2n++;
}
while (h != nb) {
shift += h;
h = nb >> log2n--;
int len = high;
high = (h - 1) | 1;
len = (high - len) / 2;
if (len > 0) {
tmp = produit(len);
tmp2 = multiplication(p, tmp);
viderListe(&p);
p = tmp2;
viderListe(&tmp);
tmp3 = multiplication(r, p);
viderListe(&r);
r = tmp3;
}
}
viderListe(&p);
tmp = left_shift(r, shift);
viderListe(&r);
return tmp;
}
void simpson(double n)
{
double a = 0;
double b = 5000;
double i = a;
double h = (b - a) / 10000;
double result = 0;
double res = 0;
double final;
while (i < b)
{
result = result + produit(n, (a + i * h) + (h / 2));
i = i + 1;
}
i = 1;
while (i < b)
{
res = res + produit(n, (a + i * h));
i = i + 1;
}
final = ((result * 4) + (res * 2) + produit(n, a) + produit(n, b)) * ((b - a) / 60000);
BIGINT produit(int n) {
BIGINT tmp, tmp2, tmp3;
initListe(&tmp);
initListe(&tmp2);
initListe(&tmp3);
int m = n / 2;
if (m == 0) {
N += 2;
return long2bigint(N);
}
if (n == 2) {
return long2bigint(((N += 2) * (N += 2)));
}
tmp = produit(n - m);
tmp2 = produit(m);
tmp3 = multiplication(tmp, tmp2);
viderListe(&tmp);
viderListe(&tmp2);
return tmp3;
}
int main(int argc, char **argv)
{
srand((time)NULL);
printf("Taille structure = %u\n", sizeof(Tableau)); // (taille du tableau * taille int) + (taille du champs 'taille') = 100*4 + 1 = 404
/* int a = 0; // On initialise arbitrairement la variable a
printf("%d\n", alea(a));
*/
Tableau T = initialise(T);
affiche(T);
printf("Elément minimum du tableau : %d\n", minimum(T));
if (produit(T) < 0) printf("Produit trop grand"); // Evite d'afficher un produit négatif sur des entiers non signés
else printf("Produit des éléments du tableau : %d\n", produit(T));
// Décalage //
T = decalage(T);
putchar('\n');
printf("Tableau après décalage : \n");
affiche(T);
printf("Taille du tableau après le décalage = %d\n\n", T.taille);
// Trie //
printf("Après trie du tableau : \n");
T = trie(T);
affiche(T);
return 0;
}
void rectangles(double n)
{
double a = 0;
double b = 5000;
double i = a;
double h = (b - a) / 10000;
double result = 0;
while (i < b)
{
result = result + produit(n, (a + i * h));
i = i + 1;
}
result = result * h;
prompt(result, result - (M_PI / 2), n, 1);
}
// Construction du gradient du poids de l'épi
void Calculs::construction_gradient()
{
G.resize(34);
for(i=0;i<34;i++)
{
G[i] = 0;
}
for(i=0;i<34;i++)
{
for(k=1;k<34;k++)
{
AA = produit(dFdU,Z[k]);
G[i] = G[i]+dGdU[i][k]-AA[i];
}
//cout << i << " " << G[i] << endl;
}
}
// création des états adjoints Z
void Calculs::construction_adjoints()
{
transposition(dGdU);
transposition(dGdX);
transposition(dFdU);
transposition(dFdX);
Z.resize(35);
for(i=0;i<Z.size();i++) // initialisation de Z
{ //
Z[i].resize(34); //
} //
for(i=0;i<Z.size();i++) //
{ //
for(j=0;j<Z[i].size();j++) //
{ //
Z[i][j] = 0; //
} //
} //
for(i=0;i<Id.size();i++)
{
for(j=0;j<Id[i].size();j++)
{
dFdX[i][j] = dFdX[i][j] + Id[i][j];
}
}
for(i=33;i>-1;i--)
{
for(j=0;j<dFdX[0].size();j++)
{
AA = produit(dFdX,Z[i+1]);
Z[i][j] = AA[j]-dGdX[j][i];
}
}
//for(j=0;j<35;j++){
// for(i=0;i<34;i++)
// {
// cout << Z[j][i] << " " ;
// }
// cout << endl;}
}
/*!
* \brief Calcule la littérale résultante de l'expression
*/
Litterale* LitteraleExpression::eval() {
Interpreteur& inter=Interpreteur::getInstance();
FactoryLitterale& fl=FactoryLitterale::getInstance();
FactoryOperateur& fo=FactoryOperateur::getInstance();
string s(exp);
regex e;
smatch m;
// Traitement des opérateurs unaires s'appliquant à l'expression
regex opUnaire("([A-Z](?:[A-Z]|[0-9])*)\\(([^,\\(\\)]+)\\)");
while (std::regex_search (s,m,opUnaire)) {
cout<<m[0]<<" "<<m[1]<<" "<<m[2]<<endl;
// m[1] l'opérateur et m[2] l'argument
if(inter.isOperateur(m[1])) {
Litterale* l1 = fl.newLitteraleExpression(m[2])->eval();
Operateur* op= inter.toOperateur(m[1]);
return op->applyUnaire(l1);
}
}
// Traitement des opérateurs binaires s'appliquant à l'expression
regex opBinaire("([A-Z](?:[A-Z]|[0-9])*)\\(([^,\\(]+),([^,\\(\\)]+)\\)");
while (std::regex_search (s,m,opBinaire)) {
//cout<<m[0]<<" "<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// m[1] l'opérateur et m[2] l'argument 1 et m[2] l'argument 2
if(inter.isOperateur(m[1])) {
Litterale* l1 = fl.newLitteraleExpression(m[2])->eval();
Litterale* l2 = fl.newLitteraleExpression(m[3])->eval();
Operateur* op= inter.toOperateur(m[1]);
return op->applyBinaire(l1,l2);
}
}
// Remplacement des variables par leur contenu
regex atome("((?:[[:upper:]]{1})(?:[[:upper:]]|[[:digit:]])*)");
while (regex_search(s,m,atome)) {
LitteraleAtome* var = LitteraleAtome::getVar(m[1]);
if(var) {
Litterale* c = var->getValeur();
s.replace(s.find(m[0]), m[0].length(), c->toString());
}
}
// Traitement des groupes parenthésés
// Le but est de ne se retrouver qu'avec
// une suite d'opérations arithmétiques sans parenthèses
regex paren("\\(([^\\(]*?)\\)");
while (regex_search(s,m,paren)) {
//cout<<m[0]<<" va être remplcé par "<<m[1]<<endl;
Litterale* c = fl.newLitteraleExpression(m[1])->eval();
//cout<<"av. "<<s<<endl;
s.replace(s.find(m[0]), m[0].length(), c->toString());
//cout<<"apr. "<<s<<endl;
}
// Traitement des + et -
regex somme("([^\\+]*[1-9])([\\+-])(.+)");
if (regex_search(s,m,somme)) {
//cout<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// Conversion en littérale des deux cotés
Litterale* l1=fl.newLitteraleExpression(m[1])->eval(); // On converti en littérale la partie gauche
Litterale* l2=fl.newLitteraleExpression(m[3])->eval(); // On converti en littérale la partie droite
// Création de l'opérateur
OperateurNumerique* op=fo.newOperateurNumerique(m[2]);
// Application du résultat
Litterale* l3=op->applyBinaire(l1, l2);
return l3;
}
// Traitement des * et /
regex produit("([^\\+]*[1-9])([\\*/])(.+)");
if (regex_search(s,m,produit)) {
//cout<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// Conversion en littérale des deux cotés
Litterale* l1=fl.newLitteraleExpression(m[1])->eval(); // On converti en littérale la partie gauche
Litterale* l2=fl.newLitteraleExpression(m[3])->eval(); // On converti en littérale la partie droite
// Création de l'opérateur
OperateurNumerique* op=fo.newOperateurNumerique(m[2]);
// Application du résultat
Litterale* l3=op->applyBinaire(l1, l2);
return l3;
}
// On vérifie que ce n'est pas tout simplement une littérale
if(inter.isLitterale(s)) {
return inter.toLitterale(s);
}
return nullptr;
}
int main()
{
printf("%i\n", produit());
return 0;
}