Operators

Once introduced to variables and constants, we can begin to operate with them by using . What follows is a complete list of operators. At this point, it is likely not necessary to know all of them, but they are all listed here to also serve as reference.

Assignment operator (=)

The assignment operator assigns a value to a variable.

x = 5;

This statement assigns the integer value 5 to the variable x. The assignment operation always takes place from right to left, and never the other way around:

x = y;

This statement assigns to variable x the value contained in variable y. The value of x at the moment this statement is executed is lost and replaced by the value of y.

Consider also that we are only assigning the value of y to x at the moment of the assignment operation. Therefore, if y changes at a later moment, it will not affect the new value taken by x.

For example, let’s have a look at the following code – I have included the evolution of the content stored in the variables as comments:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// assignment operator
#include <iostream>
using namespace std;

int main ()
{
  int a, b;         // a:?,  b:?
  a = 10;           // a:10, b:?
  b = 4;            // a:10, b:4
  a = b;            // a:4,  b:4
  b = 7;            // a:4,  b:7

  cout << "a:";
  cout << a;
  cout << " b:";
  cout << b;
}

a:4 b:7

This program prints on screen the final values of a and b (4 and 7, respectively). Notice how a was not affected by the final modification of b, even though we declared a = b earlier.

Assignment operations are expressions that can be evaluated. That means that the assignment itself has a value, and -for fundamental types- this value is the one assigned in the operation. For example:

y = 2 + (x = 5);

In this expression, y is assigned the result of adding 2 and the value of another assignment expression (which has itself a value of 5). It is roughly equivalent to:

1
2

x = 5;
y = 2 + x;

With the final result of assigning 7 to y.

The following expression is also valid in C++:

x = y = z = 5;

It assigns 5 to the all three variables: x, y and z; always from right-to-left.

The assignment operator assigns a value to a variable.This statement assigns the integer valueto the variable. The assignment operation always takes place from right to left, and never the other way around:This statement assigns to variablethe value contained in variable. The value ofat the moment this statement is executed is lost and replaced by the value ofConsider also that we are only assigning the value oftoat the moment of the assignment operation. Therefore, ifchanges at a later moment, it will not affect the new value taken byFor example, let’s have a look at the following code – I have included the evolution of the content stored in the variables as comments:This program prints on screen the final values ofand(4 and 7, respectively). Notice howwas not affected by the final modification of, even though we declaredearlier.Assignment operations are expressions that can be evaluated. That means that the assignment itself has a value, and -for fundamental types- this value is the one assigned in the operation. For example:In this expression,is assigned the result of adding 2 and the value of another assignment expression (which has itself a value of 5). It is roughly equivalent to:With the final result of assigning 7 toThe following expression is also valid in C++:It assigns 5 to the all three variables:and; always from right-to-left.

Arithmetic operators ( +, -, *, /, % )

The five arithmetical operations supported by C++ are:

operatordescription
+addition
-subtraction
*multiplication
/division
%modulo

Operations of addition, subtraction, multiplication and division correspond literally to their respective mathematical operators. The last one, , represented by a percentage sign (%), gives the remainder of a division of two values. For example:

x = 11 % 3;

results in variable x containing the value 2, since dividing 11 by 3 results in 3, with a remainder of 2.

The five arithmetical operations supported by C++ are:Operations of addition, subtraction, multiplication and division correspond literally to their respective mathematical operators. The last one,, represented by a percentage sign (), gives the remainder of a division of two values. For example:results in variablecontaining the value 2, since dividing 11 by 3 results in 3, with a remainder of 2.

Compound assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

Compound assignment operators modify the current value of a variable by performing an operation on it. They are equivalent to assigning the result of an operation to the first operand:

expressionequivalent to…
y += x;y = y + x;
x -= 5;x = x - 5;
x /= y;x = x / y;
price *= units + 1;price = price * (units+1);

and the same for all other compound assignment operators. For example:

1
2
3
4
5
6
7
8
9
10
11

// compound assignment operators
#include <iostream>
using namespace std;

int main ()
{
  int a, b=3;
  a = b;
  a+=2;             // equivalent to a=a+2
  cout << a;
}

5

Compound assignment operators modify the current value of a variable by performing an operation on it. They are equivalent to assigning the result of an operation to the first operand:and the same for all other compound assignment operators. For example:

Increment and decrement (++, –)

Some expression can be shortened even more: the increase operator (++) and the decrease operator (--) increase or reduce by one the value stored in a variable. They are equivalent to +=1 and to -=1, respectively. Thus:

1
2
3

++x;
x+=1;
x=x+1;

are all equivalent in its functionality; the three of them increase by one the value of x.

In the early C compilers, the three previous expressions may have produced different executable code depending on which one was used. Nowadays, this type of code optimization is generally performed automatically by the compiler, thus the three expressions should produce exactly the same executable code.

A peculiarity of this operator is that it can be used both as a prefix and as a suffix. That means that it can be written either before the variable name (++x) or after it (x++). Although in simple expressions like x++ or ++x, both have exactly the same meaning; in other expressions in which the result of the increment or decrement operation is evaluated, they may have an important difference in their meaning: In the case that the increase operator is used as a prefix (++x) of the value, the expression evaluates to the final value of x, once it is already increased. On the other hand, in case that it is used as a suffix (x++), the value is also increased, but the expression evaluates to the value that x had before being increased. Notice the difference:

Example 1Example 2

x = 3;
y = ++x;
// x contains 4, y contains 4


x = 3;
y = x++;
// x contains 4, y contains 3


In , the value assigned to y is the value of x after being increased. While in , it is the value x had before being increased.

Some expression can be shortened even more: the increase operator () and the decrease operator () increase or reduce by one the value stored in a variable. They are equivalent toand to, respectively. Thus:are all equivalent in its functionality; the three of them increase by one the value ofIn the early C compilers, the three previous expressions may have produced different executable code depending on which one was used. Nowadays, this type of code optimization is generally performed automatically by the compiler, thus the three expressions should produce exactly the same executable code.A peculiarity of this operator is that it can be used both as a prefix and as a suffix. That means that it can be written either before the variable name () or after it (). Although in simple expressions likeor, both have exactly the same meaning; in other expressions in which the result of the increment or decrement operation is evaluated, they may have an important difference in their meaning: In the case that the increase operator is used as a prefix () of the value, the expression evaluates to the final value of, once it is already increased. On the other hand, in case that it is used as a suffix (), the value is also increased, but the expression evaluates to the value that x had before being increased. Notice the difference:In, the value assigned tois the value ofafter being increased. While in, it is the valuehad before being increased.

Relational and comparison operators ( ==, !=, >, <, >=, <= )

Two expressions can be compared using relational and equality operators. For example, to know if two values are equal or if one is greater than the other.

The result of such an operation is either true or false (i.e., a Boolean value).

The relational operators in C++ are:

operatordescription
==Equal to
!=Not equal to
<Less than
>Greater than
<=Less than or equal to
>=Greater than or equal to

Here there are some examples:

1
2
3
4
5

(7 == 5)     // evaluates to false
(5 > 4)      // evaluates to true
(3 != 2)     // evaluates to true
(6 >= 6)     // evaluates to true
(5 < 5)      // evaluates to false 

Of course, it’s not just numeric constants that can be compared, but just any value, including, of course, variables. Suppose that a=2, b=3 and c=6, then:

1
2
3
4

(a == 5)     // evaluates to false, since a is not equal to 5
(a*b >= c)   // evaluates to true, since (2*3 >= 6) is true
(b+4 > a*c)  // evaluates to false, since (3+4 > 2*6) is false
((b=2) == a) // evaluates to true 

Be careful! The assignment operator (operator =, with one equal sign) is not the same as the equality comparison operator (operator ==, with two equal signs); the first one (=) assigns the value on the right-hand to the variable on its left, while the other (==) compares whether the values on both sides of the operator are equal. Therefore, in the last expression ((b=2) == a), we first assigned the value 2 to b and then we compared it to a (that also stores the value 2), yielding true.

Two expressions can be compared using relational and equality operators. For example, to know if two values are equal or if one is greater than the other.The result of such an operation is either true or false (i.e., a Boolean value).The relational operators in C++ are:Here there are some examples:Of course, it’s not just numeric constants that can be compared, but just any value, including, of course, variables. Suppose thatand, then:Be careful! The assignment operator (operator, with one equal sign) is not the same as the equality comparison operator (operator, with two equal signs); the first one () assigns the value on the right-hand to the variable on its left, while the other () compares whether the values on both sides of the operator are equal. Therefore, in the last expression (), we first assigned the valuetoand then we compared it to(that also stores the value 2), yielding

Logical operators ( !, &&, || )

The operator ! is the C++ operator for the Boolean operation NOT. It has only one operand, to its right, and inverts it, producing false if its operand is true, and true if its operand is false. Basically, it returns the opposite Boolean value of evaluating its operand. For example:

1
2
3
4

!(5 == 5)   // evaluates to false because the expression at its right (5 == 5) is true
!(6 <= 4)   // evaluates to true because (6 <= 4) would be false
!true       // evaluates to false
!false      // evaluates to true 

The logical operators && and || are used when evaluating two expressions to obtain a single relational result. The operator && corresponds to the Boolean logical operation AND, which yields true if both its operands are true, and false otherwise. The following panel shows the result of operator && evaluating the expression a&&b:

&& OPERATOR (and)
aba && b
truetruetrue
truefalsefalse
falsetruefalse
falsefalsefalse

The operator || corresponds to the Boolean logical operation OR, which yields true if either of its operands is true, thus being false only when both operands are false. Here are the possible results of a||b:

|| OPERATOR (or)
aba || b
truetruetrue
truefalsetrue
falsetruetrue
falsefalsefalse

For example:

1
2

( (5 == 5) && (3 > 6) )  // evaluates to false ( true && false )
( (5 == 5) || (3 > 6) )  // evaluates to true ( true || false ) 

When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the combined relational result, ignoring the rest. Therefore, in the last example ((5==5)||(3>6)), C++ evaluates first whether 5==5 is true, and if so, it never checks whether 3>6 is true or not. This is known as , and works like this for these operators:

operatorshort-circuit
&&if the left-hand side expression is false, the combined result is false (the right-hand side expression is never evaluated).
||if the left-hand side expression is true, the combined result is true (the right-hand side expression is never evaluated).

This is mostly important when the right-hand expression has side effects, such as altering values:

if ( (i<10) && (++i<n) ) { /*...*/ }   // note that the condition increments i 

Here, the combined conditional expression would increase i by one, but only if the condition on the left of && is true, because otherwise, the condition on the right-hand side (++i<n) is never evaluated.

The operatoris the C++ operator for the Boolean operation NOT. It has only one operand, to its right, and inverts it, producingif its operand is, andif its operand is. Basically, it returns the opposite Boolean value of evaluating its operand. For example:The logical operatorsandare used when evaluating two expressions to obtain a single relational result. The operatorcorresponds to the Boolean logical operation AND, which yieldsif both its operands are, andotherwise. The following panel shows the result of operatorevaluating the expressionThe operatorcorresponds to the Boolean logical operation OR, which yieldsif either of its operands is, thus being false only when both operands are false. Here are the possible results ofFor example:When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the combined relational result, ignoring the rest. Therefore, in the last example (), C++ evaluates first whetheris, and if so, it never checks whetherisor not. This is known as, and works like this for these operators:This is mostly important when the right-hand expression has side effects, such as altering values:Here, the combined conditional expression would increaseby one, but only if the condition on the left ofis, because otherwise, the condition on the right-hand side () is never evaluated.

Conditional ternary operator ( ? )

The conditional operator evaluates an expression, returning one value if that expression evaluates to true, and a different one if the expression evaluates as false. Its syntax is:

condition ? result1 : result2

If condition is true, the entire expression evaluates to result1, and otherwise to result2.

1
2
3
4

7==5 ? 4 : 3     // evaluates to 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3   // evaluates to 4, since 7 is equal to 5+2.
5>3 ? a : b      // evaluates to the value of a, since 5 is greater than 3.
a>b ? a : b      // evaluates to whichever is greater, a or b.  

For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// conditional operator
#include <iostream>
using namespace std;

int main ()
{
  int a,b,c;

  a=2;
  b=7;
  c = (a>b) ? a : b;

  cout << c << '\n';
}

7

In this example, a was 2, and b was 7, so the expression being evaluated (a>b) was not true, thus the first value specified after the question mark was discarded in favor of the second value (the one after the colon) which was b (with a value of 7).

The conditional operator evaluates an expression, returning one value if that expression evaluates to, and a different one if the expression evaluates as. Its syntax is:Ifis, the entire expression evaluates to, and otherwise toFor example:In this example,was 2, andwas 7, so the expression being evaluated () was not, thus the first value specified after the question mark was discarded in favor of the second value (the one after the colon) which was(with a value of 7).

Comma operator ( , )

The comma operator (,) is used to separate two or more expressions that are included where only one expression is expected. When the set of expressions has to be evaluated for a value, only the right-most expression is considered.

For example, the following code:

a = (b=3, b+2);

would first assign the value 3 to b, and then assign b+2 to variable a. So, at the end, variable a would contain the value 5 while variable b would contain value 3.

The comma operator () is used to separate two or more expressions that are included where only one expression is expected. When the set of expressions has to be evaluated for a value, only the right-most expression is considered.For example, the following code:would first assign the value 3 to, and then assignto variable. So, at the end, variablewould contain the value 5 while variablewould contain value 3.

Bitwise operators ( &, |, ^, ~, <<, >> )

Bitwise operators modify variables considering the bit patterns that represent the values they store.

operatorasm equivalentdescription
&ANDBitwise AND
|ORBitwise inclusive OR
^XORBitwise exclusive OR
~NOTUnary complement (bit inversion)
<<SHLShift bits left
>>SHRShift bits right

Bitwise operators modify variables considering the bit patterns that represent the values they store.

Explicit type casting operator

Type casting operators allow to convert a value of a given type to another type. There are several ways to do this in C++. The simplest one, which has been inherited from the C language, is to precede the expression to be converted by the new type enclosed between parentheses (()):

1
2
3

int i;
float f = 3.14;
i = (int) f;

The previous code converts the floating-point number 3.14 to an integer value (3); the remainder is lost. Here, the typecasting operator was (int). Another way to do the same thing in C++ is to use the functional notation preceding the expression to be converted by the type and enclosing the expression between parentheses:

i = int (f);

Both ways of casting types are valid in C++.

Type casting operators allow to convert a value of a given type to another type. There are several ways to do this in C++. The simplest one, which has been inherited from the C language, is to precede the expression to be converted by the new type enclosed between parentheses (()):The previous code converts the floating-point numberto an integer value (); the remainder is lost. Here, the typecasting operator was. Another way to do the same thing in C++ is to use the functional notation preceding the expression to be converted by the type and enclosing the expression between parentheses:Both ways of casting types are valid in C++.

sizeof

This operator accepts one parameter, which can be either a type or a variable, and returns the size in bytes of that type or object:

x = sizeof (char);

Here, x is assigned the value 1, because char is a type with a size of one byte.

The value returned by sizeof is a compile-time constant, so it is always determined before program execution.

This operator accepts one parameter, which can be either a type or a variable, and returns the size in bytes of that type or object:Here,is assigned the value, becauseis a type with a size of one byte.The value returned byis a compile-time constant, so it is always determined before program execution.

Other operators

Later in these tutorials, we will see a few more operators, like the ones referring to pointers or the specifics for object-oriented programming.

Precedence of operators

A single expression may have multiple operators. For example:

x = 5 + 7 % 2;

In C++, the above expression always assigns 6 to variable x, because the % operator has a higher precedence than the + operator, and is always evaluated before. Parts of the expressions can be enclosed in parenthesis to override this precedence order, or to make explicitly clear the intended effect. Notice the difference:

1
2

x = 5 + (7 % 2);    // x = 6 (same as without parenthesis)
x = (5 + 7) % 2;    // x = 0 

From greatest to smallest priority, C++ operators are evaluated in the following order:
LevelPrecedence groupOperatorDescriptionGrouping
1Scope::scope qualifierLeft-to-right
2Postfix (unary)++ --postfix increment / decrementLeft-to-right
()functional forms
[]subscript
. ->member access
3Prefix (unary)++ --prefix increment / decrementRight-to-left
~ !bitwise NOT / logical NOT
+ -unary prefix
& *reference / dereference
new deleteallocation / deallocation
sizeofparameter pack
()C-style type-casting
4Pointer-to-member.* ->*access pointerLeft-to-right
5Arithmetic: scaling* / %multiply, divide, moduloLeft-to-right
6Arithmetic: addition+ -addition, subtractionLeft-to-right
7Bitwise shift<< >>shift left, shift rightLeft-to-right
8Relational< > <= >=comparison operatorsLeft-to-right
9Equality== !=equality / inequalityLeft-to-right
10And&bitwise ANDLeft-to-right
11Exclusive or^bitwise XORLeft-to-right
12Inclusive or|bitwise ORLeft-to-right
13Conjunction&&logical ANDLeft-to-right
14Disjunction||logical ORLeft-to-right
15Assignment-level expressions= *= /= %= += -=
>>= <<= &= ^= |=assignment / compound assignmentRight-to-left
?:conditional operator
16Sequencing,comma separatorLeft-to-right

When an expression has two operators with the same precedence level, determines which one is evaluated first: either left-to-right or right-to-left.

Enclosing all sub-statements in parentheses (even those unnecessary because of their precedence) improves code readability.

A single expression may have multiple operators. For example:In C++, the above expression always assigns 6 to variable, because theoperator has a higher precedence than theoperator, and is always evaluated before. Parts of the expressions can be enclosed in parenthesis to override this precedence order, or to make explicitly clear the intended effect. Notice the difference:From greatest to smallest priority, C++ operators are evaluated in the following order:When an expression has two operators with the same precedence level,determines which one is evaluated first: either left-to-right or right-to-left.Enclosing all sub-statements in parentheses (even those unnecessary because of their precedence) improves code readability.

Fonction :

fraction

Résumé :

Calcul de fraction en ligne avec étapes et détails des calculs :
simplification, addition, soustraction, multiplication, division, puissance, inverse de fractions.

fraction en ligne

Description :

Calculatrice de fraction

Une fraction est un nombre qui s’écrit de la manière suivante : `a/b` avec a et b deux entiers et b non nul.
Une fraction peut aussi être définie comme un nombre rationnel.

La fonction fraction s’utilise comme une calculatrice de fraction, elle offre la possibilité de réaliser
en ligne des calculs de fraction,
elle permet de simplifier une fraction en la mettant sous sa forme irréductible,
elle permet des simplifier des fractions, en effectuant les différentes opérations arithmétiques puis en renvoyant
le résultat sous la forme d’une fraction réduite.

Le calculateur de fraction permet :

Addition de fractions en ligne

Lepermet :

La calculatrice de fraction en ligne permet le calcul de la somme de fractions,
ainsi pour calculer la somme de fractions comme celles ci `1/4` et `4/5`, il faut saisir
fraction(`1/4+4/5`),
après calcul, on obtient le résultat `21/20`.

Le calcul de fraction s’applique également à des fractions qui comportent des lettres, ainsi pour le
calcul de la somme de fraction avec des lettres comme les suivantes `a/b` et `c/d`,
il faut saisir fraction(`a/b+c/d`), après calcul,
on obtient le résultat `(a*d+c*b)/(b*d)`

Pour additionner deux fractions, la calculatrice va réduire les fractions au même dénominateur, puis additionner
les numérateurs, la fraction obtenue va ensuite être réduite avant que le résultat soit retourné. Toutes les étapes qui ont permis de
faire la somme de fraction sont renvoyées par le calculateur.

Il est possible d’additionner des fractions entre elles, mais aussi avec d’autres expressions algébriques, après calcul,
le résultat sera renvoyé sous forme fractionnaire

Soustraction de fractions en ligne

La calculatrice de fraction permet de calculer la différence de fractions en ligne,
ainsi pour calculer la différence des fractions `4/5` et `1/5`, il faut saisir
fraction(`4/5-1/5`) , après calcul,
on obtient le résultat `3/5`.

La calculatrice s’utilise également sur des expressions fractionnaires littérales, ainsi pour calculer
la différence des fractions `a/b` et `c/d`, il faut saisir
fraction(`a/b-c/d`), après calcul,
on obtient le résultat `(a*d-c*b)/(b*d)`.

Pour soustraire deux fractions, la calculatrice va réduire les fractions au même dénominateur, puis soustraire les numérateurs,
la calculatrice va réduire la fraction, c’est à dire la simplifier avant de retourner le résultat. Les détails des calculs qui ont permis de
faire la différence de fraction sont renvoyés par le calculateur.

Il est possible de soustraire des fractions entre elles, mais aussi avec d’autres expressions algébriques, après calcul,
le résultat sera renvoyé sous forme fractionnaire

Produit de fractions en ligne

Multiplier des fractions en ligne avec la calculatrice de fraction est également possible,
la multiplication de fractions en ligne s’applique a des fractions numériques, ainsi pour
calculer le produit de fractions comme celles qui suivent `4/3` et `2/5`,
il faut saisir fraction(`4/3*2/5`), après calcul,
on obtient le résultat `8/15`.

Le calcul du produit de fraction littérale fait également partie des fonctionnalités de la
calculatrice en ligne de fraction, ainsi pour calculer le produit des fractions `a/b` et `c/d`,
il faut saisir fraction(`a/b*c/d`)“,après calcul,
on obtient le résultat `(a*c)/(b*d)`

Pour calculer un produit de fractions, la calculatrice va multiplier les numérateurs entre eux, puis multiplier les dénominateurs
entre eux, la calculatrice va simplifier la fraction. Le calculateur retourne aussi les détails des calculs qui ont
permis de faire le produit de fraction.

Il est possible de multiplier des fractions entre elles, mais aussi avec d’autres expressions algébriques, après calcul,
le résultat sera renvoyé sous forme fractionnaire.

Rapport de fractions en ligne

La calculatrice de fraction permet de calculer le rapport de fractions en ligne,
ainsi pour le calcul du rapport des fractions `4/3` et `2/5`, il faut saisir
fraction(`(4/3)/(2/5)`),
après calcul, on obtient le résultat `10/3`.

La calculatrice en ligne s’utilise sur des expressions fractionnaires littérales, ainsi pour calculer le rapport des fractions `a/b` et `c/d`, il faut saisir `(a/b)/(c/d)`, après calcul, on obtient le résultat `(a*d)/(b*c)`

Inverse d’une fraction

La calculatrice de fraction en ligne permet le calcul de l’inverse d’une fraction en ligne,
ainsi pour calculer l’inverse de la fraction `7/2`, il faut saisir 1/(7/2), après calcul, on obtient le résultat `2/7`.

La calculatrice fractionnaire s’applique également sur des expressions fractionnaires littérales,
ainsi pour inverser la fraction `a/b` ,
il faut saisir fraction(`1/(a/b)`), après calcul, on obtient le résultat `b/a`

Simplification de fraction en ligne

La calculatrice de fraction permet de réduire une fraction en ligne,
c’est à dire de mettre la fraction sous une forme irréductible.

Pour simplifier une fraction
comme la fraction suivante `54/28` ,il faut saisir fraction(`54/28`) ,
après calcul, on obtient le résultat `27/14` qui est donné sous la forme d’une fraction irréductible.

Pour parvenir à simplifier une fraction, la calculatrice utilise différentes méthodes de calcul, elle s’appuie notamment sur le
PGCD lorsque numérateur
et dénominateur sont des nombres entiers. La calculatrice
calcule le PGCD
pour déterminer une fraction simplifiée autrement dit une fraction irréductible. Le calculateur renvoie chaque étape du calcul.

Puissance de fractions en ligne

Le calcul de fraction en ligne avec puissance peut se faire rapidement grâce au calculateur de fraction.
Il est possible d’élever une fraction à une puissance entière et d’obtenir le résultat de ce calcul de puissance de fraction
sous la forme d’une fraction irréductible.
Par exemple pour calculer `(4/5)^3`,
il faut saisir fraction(`(4/5)^3`), après calcul,
on obtient le résultat `64/125`.
La calculatrice de fraction accessible via la fonction fraction,
permet donc de calculer simplement les puissances de fractions en ligne.

Fractions littérales

Une fraction littérale est une fraction qui fait intervenir des lettres.

La fraction `x/2` est un exemple de fraction littérale.

La calculatrice est en mesure de faire des calculs littéraux faisant intervenir des fractions.

Fractions décimales

On appelle fraction décimale, une fraction dont le numérateur est une puissance de 10, autrement dit, le numérateur est égal à 10, 100, 1000, …

La fraction `4/10` est un exemple de fraction décimale.

Le calculateur utilise les fractions décimales pour écrire sous forme de fraction irréductible tout nombre décimal.

Transformation d’un nombre décimal en fraction

La calculatrice de fraction permet de transformer un nombre décimal en fraction,
ainsi pour mettre sous la forme d’une fraction irréductible le nombre décimal suivant 0.4,
il faut saisir fraction(`0.4`),
après calcul, on obtient le résultat sous la forme d’une fraction irréductible `2/5`.

Calculer en ligne avec des fractions de pi (`pi`)

Calculer avec des fractions de pi (`pi`) est également une fonctionnalité du calculateur,
ainsi pour calculer la somme de `pi/3` et de `pi/6` sous la forme d’une fraction irréductible de pi (`pi`),
il faut saisir fraction(`pi/3+pi/6`), après calcul,
on obtient le résultat sous la forme d’une fraction irréductible `pi/2`.

Combiner des opérations sur les fractions

Le calcul de fraction peut combiner plusieurs opérations, il est possible d’additionner, de soustraire, de multiplier, de diviser des fractions dans un même calcul.
Le résultat sera retourné sous la forme d’une fraction simplifiée.

Il est possible de combiner toutes ces opérations et de les appliquer à des expressions algébriques contenant des fractions, pour obtenir le résulat avec les étapes de calculs.

Exercices sur les fractions.

Le site propose des exercices sur les nombres rationnels, autrement dit, des exercices sur les fractions, qui permettent
de s’entrainer à faire des calculs avec des nombres rationnels.

Jeux sur les fractions.

Le site propose également des jeux sur les nombres rationnels, ces jeux sur les fractions, permettent
de s’entrainer à manipuler des nombres rationnels.

Calcul de fraction en ligne avec étapes et détails des calculs :
simplification, addition, soustraction, multiplication, division, puissance, inverse de fractions.

Calcul de fraction en ligne avec étapes et détails des calculs : simplification, addition, soustraction, multiplication, division, puissance, inverse de fractions.

Syntaxe :

fraction(expression), où expression désigne l’expression fractionnaire à calculer, le résultat renvoyé par la fonction est donné sous forme fractionnaire.

fraction(expression), où expression désigne l’expression fractionnaire à calculer, le résultat renvoyé par la fonction est donné sous forme fractionnaire.

Exemples :

Calculer en ligne avec fraction (calculatrice fraction
)