teneur
1.2. Arrondi au sol (-∞ arrondi)
2.3. Prendre le reste revient-il à prendre le modulo ?
2.4. Données calculées avec le même signe
2.5. Différents symboles de données de calcul
Un : quatre tours
1.1, arrondi dans le sens 0
Regardez le code :
#include <stdio.h>
int main()
{
//本质是向0取整
int i = -2.9;
int j = 2.9;
printf("%d\n", i); //结果是：-2
printf("%d\n", j); //结果是：2
printf("%d %d\n", 5 / 2, -5 / 2); // 2 -2
return 0;
}
L'arrondi par défaut dans la direction 0 en C, le dessin explique l'arrondi dans la direction 0 :
Il existe une fonction trunc en langage C, qui utilise également l'arrondi dans la direction 0. Notez le fichier d'en-tête de référence #include<math.h>. Un exemple est le suivant :
#include <stdio.h>
#include<math.h>
int main()
{
int i = -2.9;
int j = 2.9;
printf("%d\n", i); //结果是：-2
printf("%d\n", j); //结果是：2
printf("%d\n", (int)trunc(2.9)); //结果是：2 //结果是：-2
printf("%d\n", (int)trunc(-2.9));//结果是：-2
return 0;
}1.2, -∞ arrondi (arrondi au sol)
En fait, la fonction floor est utilisée, ce qui est identique à la référence trunc ci-dessus #include<math.h>
Regardez le code :
#include<stdio.h>
#include<math.h>
int main()
{
printf("%.1f\n", floor(-2.9)); // -3.0
printf("%.1f\n", floor(-2.1)); // -3.0
printf("%.1f\n", floor(2.9)); // 2.0
printf("%.1f\n", floor(2.1)); // 2.0
return 0;
}
Explication du dessin - ∞ arrondi
1.3, +∞ arrondi
La fonction ceil est utilisée, ce qui nécessite également #include<math.h>
Regardez le code :
#include<stdio.h>
#include<math.h>
int main()
{
printf("%.1f\n", ceil(-2.9)); // -2.0
printf("%.1f\n", ceil(-2.1)); // -2.0
printf("%.1f\n", ceil(2.9)); // 3.0
printf("%.1f\n", ceil(2.1)); // 3.0
return 0;
}
Explication du dessin + ∞ arrondi :
1.4, arrondir
La fonction round est utilisée, ce qui nécessite également #include<math.h>
Regardez le code :
#include<stdio.h>
#include<math.h>
int main()
{
printf("%.1f\n", round(-2.9)); // -3.0
printf("%.1f\n", round(-2.1)); // -2.0
printf("%.1f\n", round(2.9)); // 3.0
printf("%.1f\n", round(2.1)); // 2.0
}1.5. Exemple de résumé
#include <stdio.h>
#include <math.h>
int main()
{
const char* format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";
printf("value\tround\tfloor\tceil\ttrunc\n");
printf("-----\t-----\t-----\t----\t-----\n");
printf(format, 2.3, round(2.3), floor(2.3), ceil(2.3), trunc(2.3));
printf(format, 3.8, round(3.8), floor(3.8), ceil(3.8), trunc(3.8));
printf(format, 5.5, round(5.5), floor(5.5), ceil(5.5), trunc(5.5));
printf(format, -2.3, round(-2.3), floor(-2.3), ceil(-2.3), trunc(-2.3));
printf(format, -3.8, round(-3.8), floor(-3.8), ceil(-3.8), trunc(-3.8));
printf(format, -5.5, round(-5.5), floor(-5.5), ceil(-5.5), trunc(-5.5));
return 0;
}
en conclusion:
Il existe de nombreuses méthodes d'arrondi pour les nombres à virgule flottante (entier/entier).
Deux : modulo / reste
2.1.Concept
Si a et d sont deux nombres naturels et d est différent de zéro, on peut montrer qu'il existe deux entiers uniques q et r tels que a = q*d + r et 0 ≤ r < d. où q est appelé le quotient et r est appelé le reste.
2.2 Exemples (C et Python)
#include <stdio.h>
int main()
{
int a = 10;
int d = 3;
printf("%d\n", a % d); //结果是1
//因为：a=10,d=3,q=3,r=1 0<=r<d(3)
//所以：a = q*d+r -> 10=3*3+1
int m = -10;
int n = 3;
printf("%d\n", m / n); //C语言中是-3，很好理解
printf("%d\n", m % n); //C语言是-1
return 0;
}
En langage C , on comprend bien -10/3=-3 et -10%3=-1 , il n'y a pas de contestation
En Python , -10/3 = -4 et -10%3 = 2
Pourquoi?
Conclusion : Évidemment, la définition ci-dessus de modulo ne satisfait pas l'opération modulo du langage
Analyse :
Car en C, les nombres négatifs apparaissent en -10%3, selon la définition : satisfaire a = q*d + r et 0 ≤ r < d, le reste en langage C ne satisfait pas la définition, car r<0 .
Par conséquent, nous avons une définition révisée de modulo : si a et d sont deux nombres naturels, et d est non nul, on peut prouver qu'il existe deux entiers uniques q et r, satisfaisant a = q*d + r, q est un entier avec 0 ≤ |r| < |d|. où q est appelé le quotient et r est appelé le reste.
Avec cette nouvelle définition, "modulo" en C ou Python peut être expliqué.
Explication C : -10 = (-3) * 3 + (-1)
Expliquez Python : -10 = (?) * 3 + 2, qui peut être poussé, " ? » doit être -4 (vérification ultérieure). C'est-à-dire -10 = (-4) * 3 + 2, pour répondre à la définition. .
Par conséquent, dans différentes langues, la même expression de calcul, le résultat "modulo" d'un nombre négatif est différent. On peut les appeler respectivement reste positif et reste négatif
Qu'est-ce qui détermine ce phénomène ?
On peut voir à partir de l'exemple ci-dessus que la taille du reste spécifique r dépend essentiellement du quotient q.
Et les entreprises, qui en dépend ? Dépend des règles d'arrondi lors de la division.
2.3. Prendre le reste revient-il à prendre le modulo ?
Chers camarades de classe, vous auriez dû voir que les modulo au-dessus de moi sont tous marqués d'un "". Cela montre que ces deux ne sont pas strictement équivalents (bien que la plupart des cas soient similaires) Prenez le reste ou le module, vous devez calculer le quotient, et ensuite vous pouvez obtenir le reste.
Essentiel 1 arrondi :
Reste : Faites le quotient autant que possible et arrondissez à 0.
Modulo : Faites le quotient autant que possible, en arrondissant dans le sens de -∞.
Donc:
Le % dans C est en fait un reste.
% en Python est en fait un modulo.
Comprendre la chaîne :
Pour tout nombre supérieur à 0, effectuez un arrondi 0 et un arrondi -∞ dessus, et la direction d'arrondi est cohérente. Par conséquent, prendre le modulo équivaut à prendre le reste : pour tout nombre inférieur à 0, il est arrondi dans le sens de 0 et -∞, et le sens de l'arrondi est opposé. Donc prendre le modulo n'est pas équivalent à prendre le reste
Le quotient obtenu en divisant les données par le même signe doit être un nombre positif (nombre positif vs entier positif), c'est-à-dire supérieur à 0 ! Par conséquent, en arrondissant son quotient, prendre le modulo équivaut à prendre le reste.
Notation essence 2 :
Les deux données impliquées dans le reste, si elles ont le même signe, le modulo équivaut à prendre le reste
2.4. Données calculées avec le même signe
Regardez le code :
#include <stdio.h>
int main()
{
printf("%d\n", 10 / 3); // 3
printf("%d\n\n", 10 % 3);// 1
printf("%d\n", -10 / -3); // 3
printf("%d\n\n", -10 % -3); // -1
return 0;
}En Python, nous constatons que le résultat est le même que ci-dessus.
Conclusion : A travers le test comparatif, on vérifie de plus que si les deux données participent à la prise du reste, si elles ont le même signe, prendre le modulo équivaut à prendre le reste.
2.5. Différents symboles de données de calcul
Regardez le code :
#include <stdio.h>
int main()
{
printf("%d\n", -10 / 3); //结果：-3
printf("%d\n\n", -10 % 3); //结果：-1 为什么? -10=(-3)*3+(-1)
printf("%d\n", 10 / -3); //结果：-3
printf("%d\n\n", 10 % -3); //结果：1 为什么？10=(-3)*(-3)+1
return 0;
}
En Python, le résultat n'est pas comme ça.
Conclusion évidente : Si le signe est différent, la méthode pour trouver le reste, se référer à la définition précédente. Le signe du reste est le même que le dividende.
Pourquoi?
Revoyez la définition : si a et d sont deux nombres naturels et d est différent de zéro, on peut montrer qu'il existe deux entiers uniques q et r tels que a = q*d + r , q est un entier et 0 ≤ |r| < |d|. où q est appelé le quotient et r est appelé le reste
a = q*d + r se transforme en r = a - q*d se transforme en r = a + (-q*d)
Pour : x = y + z, une telle expression, le signe de x est cohérent avec les grandes données en |y|, |z|
Dans r = a + (-q*d), la valeur absolue de |a| et |-q*d| dépend de la façon dont le quotient q est arrondi.
c est arrondi à 0, c'est-à-dire que la valeur absolue de q elle-même est réduite. Comme:
-10/3=-3.333.33 arrondir à 0 -3.a=-10 |10|, -q*d=-(-3)*3=9 |9|
10/-3=-3.333.33 arrondit à 0 - 3. a=10 |10|, -q*d=-(-3)*(-3)=-9 |9|
La valeur absolue a diminué
Python est arrondi à -∞, c'est-à-dire que la valeur absolue de q elle-même augmente.
-10/3=-3.333.33 '//' arrondi à -∞ -4.a=-10 |10|, -q*d=-(-4)*3=12 |12|
10/-3=--3.333.33 '//' Arrondi à -∞ par -4. a=10 |10|, -q*d=-(-4)*(-3)=-12 |12 |
La valeur absolue a augmenté
Conclusion : Si les deux symboles de données impliqués dans le reste sont différents, dans le langage C (ou d'autres langages qui utilisent l'arrondi à 0, comme C++, Java), le symbole du reste est le même que le dividende.
2.6. Résumé
(1) Il existe de nombreuses méthodes d'arrondi pour les nombres à virgule flottante (ou division entière).
(2) Si a et d sont deux nombres naturels et d est non nul, on peut prouver qu'il existe deux entiers uniques q et r, satisfaisant a = q*d + r , q est un entier et 0 ≤ | r| < |d |. où q est appelé le quotient et r est appelé le reste.
(3) Dans différentes langues, la même expression de calcul, le résultat de "modulo" est différent. On peut les appeler respectivement reste positif et reste négatif
(4) La taille du reste spécifique r dépend essentiellement du quotient q. Le quotient, à son tour, dépend des règles d'arrondi lors de la division.
(5) Reste vs modulo : prenez le reste autant que possible pour faire le quotient, et arrondissez à 0. Prenez le modulo autant que possible pour faire le quotient, et arrondissez dans la direction -∞.
(6) Si les deux données impliquées dans la prise du reste sont de même signe, prendre le modulo revient à prendre le reste
(7) Si les deux symboles de données impliqués dans le reste sont différents, dans le langage C (ou d'autres langages qui utilisent l'arrondi à 0, comme C++, Java), le symbole du reste est le même que le dividende. (car il est arrondi à 0)