Matematica.
// ========= MATEMATICA =========
// Leggi di più qui.
/*
+ addizione
- sottrazione
* moltiplicazione
/ divisione
% modulo
++ aggiungi 1
-- sottrai 1
+= aggiungi
-= sottrai
*= moltiplica
/= dividi
*/
a = b + c / d;
a++; // a = a + 1;
a /= 10; // a = a / 10;
// === CALCOLI DI GRANDI NUMERI ===
/*
IMPORTANTE! Per i calcoli aritmetici, la cella predefinita è long (4 byte).
La moltiplicazione e la divisione usano int (2 byte).
Se, moltiplicando i numeri, il risultato supera 32'768, verrà calcolato in modo errato.
Per risolvere la situazione, è necessario scrivere (long) prima della moltiplicazione, il che costringerà MCU ad allocare memoria aggiuntiva.
*/
long val;
val = 2000000000 + 6000000; // conta correttamente (addizione)
val = 25 * 1000; // conta correttamente (moltiplicazione, meno di 32'768).
val = 35 * 1000; // conta erratamente (moltiplicazione
, oltre 32'768).
val = (long)35 * 1000; // conta correttamente (alloca memoria (long)).
val = 1000 + 35 * 10 * 100; // conta erratamente
(moltiplicazione , oltre
32'768).
val = 1000 + 35 * 10 * 100L; // conta correttamente (modificatore L).
val = (long)35 * 1000 + 35 * 1000; // conta erratamente (la seconda moltiplicazione rovina tutto).
val = (long)35 * 1000 + (long)35 * 1000; // conta correttamente (allocare memoria (long)).
// === CALCOLO FLOAT ===
// se è necessario un risultato frazionario quando si calcolano due interi - scrivere (float).
float val;
val = 100 / 3; // conta ERRATO (risultato 3.0).
val = (float)100 / 3; // calcola correttamente (specifica (float)).
val = 100.0 / 3; // calcola correttamente (c'è un numero float).
// quando si assegna un numero float a un tipo di dati intero, la parte frazionaria viene tagliata.
int val;
val = 3,25; // val prende 3.
val = 3,92; // val prende 3.
val = round(3,25); // val prende 3.
val = round(3,92); // val prende 4.
// === FUNZIONI MATEMATICHE ===
// Limita l'intervallo di val tra low e high.
val = constrain(val, low, high);
// Converti l'intervallo di val (da inMin a inMax) in un nuovo intervallo (da outMin a outMax).
val = map(val, inMin, inMax, outMin, outMax);
min(a, b); // Restituisce il numero minore di a e b.
max(a, b); // Restituisce il numero maggiore di a e b.
abs(x); // Il valore assoluto di un numero.
round(x); // Arrotondamento matematico.
radians(deg); // Converti i gradi in radianti.
degrees(rad); // Converti i radianti in gradi.
sq(x); // Quadrato di un numero (il numero moltiplicato per se stesso).
cos(x) // Coseno (radianti)
sin(x) // Seno (radianti).
tan(x) // Tangente (radianti).
fabs(x) // Modulo per numeri float.
fmod(x, y) // Resto di x diviso per y per float.
sqrt(x) // Radice quadrata.
sqrtf(x) // Radice quadrata per i numeri float.
brt(x) // Radice cubica.
hypot(x, y) // Ipotenusa (radice(x*x + y*y)).
square(x) // Quadrato ( x*x ).
floor(x) // Arrotonda al numero intero verso il basso.
ceil(x) // Arrotonda al numero intero verso il alto.
exp(x) // Esponente (e^x).
cosh(x) // Coseno iperbolico (radianti).
sinh(x) // Seno iperbolico (radianti).
tanh(x) // Tangente
iperbolica (radianti).
acos(x) // Arcoseno (radianti).
asin(x) // Arcoseno (radianti).
atan(x) // Arcotangente (radianti).
atan2(y, x) // Arctangente (y / x) (permette di trovare il quadrante in cui si trova il punto).
log(x) // Logaritmo naturale di x ( ln(x) ).
log10(x) // Logaritmo decimale di x ( log_10 x).
pow(x, y) // Potenza ( x^y ).
fma(x, y, z) // Restituisce x*y + z.
fmax(x, y) // Restituisce il numero più grande.
fmin(x, y) // Restituisce il numero più piccolo.
trunc(x) // Restituisce la parte intera di un numero con punto decimale.
// === COSTANTI ===
F_CPU // frequenza di clock in Hz (16000000 per 16 MHz).
INT8_MAX // 127 Valore massimo per char, int8_t.
UINT8_MAX // 255 Valore massimo per byte, uint8_t.
INT16_MAX // 32767 Valore massimo per int, int16_t.
UINT16_MAX // 65535 Valore massimo per unsigned int, uint16_t.
INT32_MAX // 2147483647 Valore massimo per long, int32_t.
UINT32_MAX // 4294967295 Valore massimo per unsigned long, uint32_t.
M_E // 2.718281828 numero e.
M_LOG2E // 1.442695041 log_2 e.
M_LOG10E // 0.434294482 log_10 e.
M_LN2 // 0.693147181 log_e 2.
M_LN10 // 2.302585093 log_e 10.
M_PI // 3.141592654 pi.
M_PI_2 // 1.570796327 pi/2.
M_PI_4 // 0.785398163 pi/4.
M_1_PI // 0.318309886 1/pi.
M_2_PI // 0.636619772 2/pi.
M_2_SQRTPI // 1.128379167 2/radice(pi).
M_SQRT2 // 1.414213562 radice(2).
M_SQRT1_2 // 0.707106781 1/radice(2).
PI // 3.141592654 pi.
HALF_PI // 1.570796326 mezzo pi.
TWO_PI // 6.283185307 due pi.
EULER // 2.718281828 numero di Eulero е.
DEG_TO_RAD // 0.01745329 Costante di conversione da grad a rad.
RAD_TO_DEG // 57.2957786 Costante di conversione da rad a grad.