Posted on Mar 24, 2022
Dato un numero reale C (“C” come capitale), come se ne calcola il valore percentuale P? Per esempio: quanto vale il 3% di 100,0? Indicando con R il risultato, ci si può ricordare dalle scuole inferiori la filastrocca sulle proporzioni:
R sta a C come P sta a 100
in formula, con la notazione delle scuole elementari:
R : C = P : 100
mentre con la notazione delle scuole medie inferiori:
R / C = P / 100
ricordando un po’ di geometria: sfruttiamo la teoria della similitudine tra figure geometriche piane per costruire una rappresentazione geometrica come similitudine tra rettangoli (non in scala):
-------------- --------------
| | P | | R
-------------- --------------
100 C
il significato della proporzione è: il rettangolo delle percentuali con base 100 e altezza P è simile al rettangolo dei numeri reali con base C e altezza R (come sono figo!).
Con le posizioni C = 100,0 e P = 3, il risultato R vale:
C = 100,0 P = 3 R = C * P/100 = 100,0 * 3/100 = 3,0
E se vogliamo calcolare quanto vale l’aumento percentuale P di C? Il risultato R vale:
C = 100,0 P = 3 R = C * (1 + P/100) = 100,0 * (1 + 3/100) = 100,0 * (100/100 + 3/100) = 100,0 * 103/100 = 103,0
Nel seguito userò la notazione del linguaggio di programmazione C per scrivere le formule matematiche; inoltre userò un po’ di notazione del linguaggio di marcatura LaTeX per i simboli delle variabili matematiche, facendola però coincidere con la sintassi del linguaggio C. Un po’ mi irrita usare il punto invece della virgola per separare i decimali, ma la vita è dura. Mi piace l’idea che le espressioni simboliche si possano copiare e incollare in un programma C per verificarne la correttezza; in fondo, abbiamo tutti sottomano un compilatore C… nevvero?
Cercherò anche, se ne avrò voglia, di scrivere esplicitamente i passaggi delle elaborazioni matematiche, perché credo siamo in molti a essere arrugginiti nell’elaborazione delle espressioni.
Siccome nessuno legge preliminarmente ciò che scrivo: spero di non fare errori. Ognuno si arrangi.
Nei seguenti calcoli si parte con un valore C e lo si modifica applicando variazioni percentuali; i vari numeri sono indicati con C_0, C_1, eccetera, dove C_0 si legge “C con zero” o semplicemente “C zero”.
Con ciò, posto il valore iniziale C_0 = 100.0 e indicando il valore aumentato della percentuale P come C_1, il calcolo sopra si scrive:
C_0 = 100.0
P = 3
C_1 = C_0 * (1 + P/100)
= 100.0 * (1 + 3/100)
= 100.0 * (100/100 + 3/100)
= 100.0 * 103/100 = 103.0
Supponiamo di aumentare il valore iniziale C_0 di una percentuale P_1 e poi di una percentuale P_2; risulta:
C_1 = C_0 * (1 + P_1 / 100)
C_2 = C_1 * (1 + P_2 / 100)
= C_0 * (1 + P_1 / 100) * (1 + P_2 / 100)
sviluppiamo separatamente il prodotto tra binomi:
(1 + P_1 / 100) * (1 + P_2 / 100) = = (1 * (1 + P_2 / 100)) + (P_1 / 100 * (1 + P_2 / 100)) = (1 + P_2 / 100) + (P_1 / 100 + P_1 / 100 * P_2 / 100) = (1 + P_2 / 100) + (P_1 / 100 + P_1 * P_2 / 10000) = 1 + P_2 / 100 + P_1 / 100 + P_1 * P_2 / 10000 = 1 + (P_1 + P_2) / 100 + P_1 * P_2 / 10000
quindi:
C_2 = C_0 * (1 + (P_1 + P_2) / 100 + P_1 * P_2 / 10000)
In futuro svilupperemo l’interessante caso di P_1 == P_2. Per oggi, invece, esaminiamo l’interessantissimo caso: P_1 > 0, P_2 < 0; cioè: la prima variazione percentuale è un aumento, mentre la seconda è una diminuzione.
Introduciamo le seguenti posizioni, piú comode:
P > 0 M > 0 P_1 = + P P_2 = - M
l’espressione di C_2 risulta:
C_2 = C_0 * (1 + P/100) * (1 - M/100)
= C_0 * (1 + (P-M)/100 - P*M/10000)
si osserva che siccome la moltiplicazione gode della proprietà commutativa:
(1 + P/100) * (1 - M/100) = (1 - M/100) * (1 + P/100)
perciò non importa se prima avviene l’aumento e dopo la diminuzione oppure vice versa; il risultato non cambia.
Può venirci in mente la domanda: cosa succede se P == M? Per esempio, se prima aumentiamo C_0 del 3% e poi lo diminuiamo del 3%? Il risultato è:
P = M
C_2 = C_0 * (1 + (P-M)/100 - P*M/10000)
= C_0 * (1 - P * P/10000)
se P > 0:
e questo è quanto: due variazioni percentuali opposte diminuiscono il valore iniziale.
Altra domanda: due variazioni percentuali, una di aumento P e una di diminuzione M, come devono essere per lasciare C_2 == C_0? Torniamo all’espressione generale:
C_2 = C_0 * (1 + P/100) * (1 - M/100)
= C_0 * (1 + (P-M)/100 - P*M/10000)
se poniamo C_2 == C_0 possiamo semplificare:
C_0 = C_0 * (1 + (P-M)/100 - P*M/10000) 1 = 1 * (1 + (P-M)/100 - P*M/10000) 1 = 1 + (P-M)/100 - P*M/10000 0 = (P-M)/100 - P*M/10000
quindi:
(P-M)/100 = P*M/10000
P-M = P*M/100
si ricordi che P > 0 e M > 0; essendo il membro di destra positivo, deve esserlo anche quello di sinistra: questa uguaglianza è verificata solo se P > M. Se il valore iniziale C_0 aumenta di una percentuale P, è sufficiente una diminuzione percentuale minore di P per annullare l’aumento.
P-M = P*M/100 M = P - P*M/100 = P * (1 - M/100) P = M / (1 - M/100) = M / (100/100 - M/100) = M / ((100 - M) / 100) = 100 * M / (100 - M)
P-M = P*M/100 P = M + P*M/100 = M * (1 + P/100) M = P / (1 + P/100) = P / (100/100 + P/100) = P / ((100 + P) / 100) = 100 * P / (100 + P)
Per i lettori piú evoluti: la funzione M = M(P), per P > 0, è monotona crescente con asintoto M == 100; verificabile con Wolfram Alpha.
Ma quant’è la differenza tra P e M? Cioè quanto vale M in percentuale rispetto a P? Indicata con D tale percentuale:
D = 100 * M/P
essendo 0 < M/P < 1 risulta 0 < D < 100; siccome:
M = 100 * P / (100 + P)
eliminando M, risulta:
D = 100 * M * 1/P = 100 * (100 * P / (100 + P)) * 1/P = 100 * 100 / (100 + P) = 10000 / (100 + P)
Al crescere di P: M cresce; D diminuisce, perciò M cresce piú lentamente di P; maggiore è la percentuale di aumento P, minore è la diminuzione percentuale M sufficiente ad annullare P.
Il seguente programma calcola M a partire da P in modo che C_2 == C_0:
/* demo.c --
Compilare con: gcc -std=c99 -Wall -lm -o demo demo.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int
main (void)
{
double P = 10.0;
double M = 100.0 * P / (100.0 + P);
double D = 10000.0 / (100.0 + P);
double C_0 = 1234.56;
double C_2 = C_0 * (1.0 + P/100.0) * (1.0 - M/100.0);
printf("P = %11.4f%%\n", P);
printf("M = %11.4f%%\n", M);
printf("D = %11.4f%%\n", D);
printf("C_0 = %11.4f\n", C_0);
printf("C_2 = %11.4f\n", C_2);
exit(EXIT_SUCCESS);
}
/* end of file */
stampa:
P = 10.0000% M = 9.0909% D = 90.9091% C_0 = 1234.5600 C_2 = 1234.5600
Il seguente programma calcola P a partire da M in modo che C_2 == C_0:
/* demo.c --
Compilare con: gcc -std=c99 -Wall -lm -o demo demo.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int
main (void)
{
double M = 10.0;
double P = 100.0 * M / (100.0 - M);
double D = 10000.0 / (100.0 + P);
double C_0 = 1234.56;
double C_2 = C_0 * (1.0 + P/100.0) * (1.0 - M/100.0);
printf("M = %11.4f%%\n", M);
printf("P = %11.4f%%\n", P);
printf("D = %11.4f%%\n", D);
printf("C_0 = %11.4f\n", C_0);
printf("C_2 = %11.4f\n", C_2);
exit(EXIT_SUCCESS);
}
/* end of file */
stampa:
M = 10.0000% P = 11.1111% D = 90.0000% C_0 = 1234.5600 C_2 = 1234.5600