Пример #1
0
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;
}
Пример #3
0
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;
}
Пример #5
0
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;
}
Пример #6
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;}              
}
Пример #9
0
/*!
 *  \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;
}
Пример #10
0
int main()
{
printf("%i\n", produit());
return 0;
}