Salut

Alors je travaille sur des polynômes à partir d'une structure que voici :

typedef struct {
  int degree;
  double coeff[POLY_DEGREE_MAX + 1];
} poly;

Là je dois faire une fonction de dérivation, en utilisant l'arithmétique des pointeurs.

void poly_derivative(poly *ptr) {
  double *p = ptr -> coeff + ptr -> degree +1;
  while (p > ptr -> coeff){
    --p;
    *p *= p - ptr -> coeff;
  }
}

Avec par exemple le polynôme :
3X^2 + 2X + 1
La fonction me donne donc :
6X^2 + 2X

Or je devrais avoir :
6X + 2

Ce qui est normal puisque je ne me suis pas occupé des puissances...
...Et c'est là dessus que je bloque :
Je pense que je dois donc décaler tous les éléments du tableau coeff vers la gauche en écrasant celui le plus à gauche.
Mais je ne sais pas comment faire... J'ai encore du mal avec les pointeurs
Je suppose que je dois utiliser une variable de transition, mais j'arrive pas à visualiser le truc, et d'ailleurs j'y arrive pas non plus sans les pointeurs

Sachant que j'ai déjà une fonction main qui a été donnée et qui se démerde à faire l'affichage, à ne pas afficher les 0 etc... Enfin on s'en fiche, y'a rien qui nous intéresse là dedans. (Et je vais pas tout copier ici parce que y'a plusieurs fichiers, que y'a beaucoup de fonctions etc et ce serait le bordel )

Un peu d'aide

Salut,

Déjà ta fonction est vraiment mal écrite on ne comprend pas grand chose, essaie de faire des fonctions plus claires, quitte à ce qu'elle fasse 4-5 lignes de plus.
Pour ton problème de degrés c'est juste que tu ne modifie pas la degrés du polynôme tout simplement. Tu devais ajouter ptr->degree--;

Pour rendre la fonction plus claire utilise un for qui itère sur le tableau coeff

Les fonctions sont écrites de la façon attendue par le prof, et je ne pense pas que ce soit un mec qui raconte de la merde, vraiment.

Sinon je peux donner pour exemple d'autres fonctions qui fonctionnent et qui ont été validées :

void poly_opposite(poly *ptr) {
  double *p = ptr -> coeff + ptr -> degree +1;
  while (p > ptr -> coeff){
    --p;
    *p = -1;
  }
}

Donne l'opposé de la fonction

double poly_evaluate(const poly *ptr, double x) {
  const double *p = ptr -> coeff + ptr -> degree +1;
  double s = 0.0;
  while (p > ptr -> coeff){
    --p;
    s = s * x + *p;
  }
  return s;
}

Calcule le résultat pour un x donné

Et non le fait de décrémenter degree c'est pas ça, j'ai déjà essayé.
ça ne fait que supprimer le plus grand monôme.
Non mais je suis sûr à 90% que je dois décaler les valeurs dans le tableau, mais je ne sais pas comment faire.

oui il s'agit juste de décaler tes valeurs dans ton tableau

pour faire les choses étape par étape, tu peux laisser ta boucle qui calcule tes coefs tel quel, tu peux ne plus y toucher pour l'instant, elle calcule bien les coefs

tu fais une seconde boucle juste après, qui va s'occuper de décaler tes coefs

pour cela tu peux parcourir ton tableau dans le sens inverse de la première boucle, comme ça tu n'as pas à utiliser de variable temporaire puisque le coef de degré 0 s'en va

du coup tu pars de ptr->coef et t'incrementes ton pointeur jusqu'à ton grand monome

et à chaque iteration, tu écrases la valeur de *p avec celle qu'il y a dans la case suivante

et à la fin tu oublies par de mettre à jour ton int degree

une fois que ça fonctionne en deux boucles, tu peux éventuellement chercher à réunir tes deux boucles en une seule si c'est ce qui est demandé par ton prof

ah et *p *= p - ptr -> coeff;

je te conseillerais de mettre ça de façon plus lisible avec commentaire, comme ça :

// coef courant = degré du monome courant * coef_courant
*p = (p - ptr->coeff) * (*p);

déjà que ce genre de syntaxe c'est assez moche, alors à mon avis c'est mieux d'éviter certains sucre syntaxique qui ne font que rendre le code moins lisible amha

punaise, pourquoi utiliser des pointeurs pour faire ca. Tu aimes te faire du mal ?
Serieusement, une boucle for sera BEAUCOUP plus simple a lire.

Le 28 avril 2016 à 00:01:25 [DenshaOtoko] a écrit :
oui il s'agit juste de décaler tes valeurs dans ton tableau

pour faire les choses étape par étape, tu peux laisser ta boucle qui calcule tes coefs tel quel, tu peux ne plus y toucher pour l'instant, elle calcule bien les coefs

tu fais une seconde boucle juste après, qui va s'occuper de décaler tes coefs

pour cela tu peux parcourir ton tableau dans le sens inverse de la première boucle, comme ça tu n'as pas à utiliser de variable temporaire puisque le coef de degré 0 s'en va

du coup tu pars de ptr->coef et t'incrementes ton pointeur jusqu'à ton grand monome

et à chaque iteration, tu écrases la valeur de *p avec celle qu'il y a dans la case suivante

et à la fin tu oublies par de mettre à jour ton int degree

une fois que ça fonctionne en deux boucles, tu peux éventuellement chercher à réunir tes deux boucles en une seule si c'est ce qui est demandé par ton prof

SpoilAfficherMasquer

tu es obligé d'utiliser un tableau pour ton double coef ? car avec une liste chainée ce serait beaucoup plus simple, il suffirait de supprimer la tête de liste

OK merci je vais regarder ça

Le 28 avril 2016 à 05:55:36 godrik a écrit :
punaise, pourquoi utiliser des pointeurs pour faire ca. Tu aimes te faire du mal ?
Serieusement, une boucle for sera BEAUCOUP plus simple a lire.

parce que je suis les consignes

Bon j'ai plus ou moins réussi.
C'est à dire que ça fonctionne, mais le code est dégueulasse je mélange les pointeurs et l'utilisation classique des tableaux

Si quelqu'un peut m'aider à "traduire" la 2eme boucle avec des pointeurs...

void poly_derivative(poly *ptr) {
  double *p = ptr -> coeff + ptr -> degree + 1;
  while (p > ptr -> coeff){
    --p;
    *p *= p - ptr -> coeff;
  }
  int k = 0;
  ptr -> degree -= 1;
  while (k <= ptr -> degree){
    ptr -> coeff[k] = ptr -> coeff[k + 1];
    ++k;
  }
}

Et si jamais c'est possible de tout faire en une seule boucle...

maintenant que tu as réussi à obtenir ce que tu voulais avec ton approche de base
je te suggère de mettre ça sous forme de boucles for qui sera nettement plus lisible comme dit à plusieurs reprises plus haut

tu peux faire en sorte que tes deux boucles parcours ton tableau dans le même sens, comme ça c'est encore plus lisible

double *big_monome = ptr->coeff + ptr->degree;

pour double* ptr_courant allant de ptr->coef à big_monome
mettre à jour le coef courant en le multipliant par le degré du monome courant
   
pour double* ptr_courant allant de ptr->coef à big_monome
mettre dans ptr_courant le coef correspondant au degré du monome courant

C'est à dire que ça fonctionne, mais le code est dégueulasse je mélange les pointeurs et l'utilisation classique des tableaux

tu fais allusion aux ptr->coef[k] ?

l'écriture a[b] est du sucre syntaxique pour *(a+b), donc que t'écrives l'un ou l'autre ça signifie pareil normalement sauf que l'un est nettement plus lisible que l'autre