0

NUMERICAL COMPUTATIONS
WITH C

DEPARTMENT OF STATISTICS
ASUTOSH COLLEGE
KOLKATA
C Programming asutoshstat@gmail.com
 1

Numerical Computations with C

Operators and Expressions
C supports a rich set of built-in operators. An operator is a symbol that tells the compiler to
perform certain mathematical or logical manipulations. Operators are used in programs to
manipulate data and variables. The data items that operators act upon are called operands. An
expression is a sequence of operands and operators that reduce to a single value. For example,
5+10 is an expression whose value is 15.
C operators can be classified into a number of categories. They include
 Arithmetic Operators
 Relational Operators
 Logical Operators
 Assignment Operators
 Increment / Decrement Operators

Arithmetic Operators
There are five arithmetic operators in C. They are

Operator Purpose
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulo division (remainder after integer division)

The operands acted upon by arithmetic operators must represent numeric values. Thus, the
operands can be integer quantities, floating-point quantities or characters (remember that
character constants represent integer values, as determined by the computer’s character set).
The remainder operator (%) requires that both operands be integers and the second operand be
non-zero. Similarly, the division operator (/) requires that the second operand be non-zero.

Integer Arithmetic
When both the operands in a single arithmetic expression, such as a + b, are integers, the
expression is called integer expression, and the operation is called integer arithmetic. Integer
arithmetic always yields an integer value.
Example: Suppose that a and b are integer variables whose values are 10 and 3, respectively.
Arithmetic expressions involving these variables together with their resulting values are shown
below:

C Programming asutoshstat@gmail.com
 2

Expression Value
a+b 13
a–b 7
a*b 30
a/b 3
a%b 1
Note:
 Integer division truncated any fractional part.
 The modulo division operator produces the remainder of an integer division.

Real Arithmetic
An arithmetic operation involving only real operands is called real arithmetic. A real operand
may assume values either in decimal or exponential notation. Since floating-point values are
rounded to the number of significant digits permissible, the final value is an approximation of
the correct result. The operator % cannot be used with real operands.
Example: Suppose that v1 and v2 are floating-point variables whose values are 12.5 and 2.0,
respectively. Arithmetic expressions involving these variables together with their resulting
values are shown below:
Expression Value
v1 + v2 14.5
v1 – v2 10.5
v1 * v2 25.0
v1 / v2 6.25

Mixed-Mode Arithmetic
When one of the operands is real and the other is integer, the expression is called a mixed-
mode arithmetic expression. If either operand is of the real type, then only the real operation is
performed and the result is always a real number. Thus
15/10.0 = 1.5
whereas
15/10 = 1.

Relational Operators
There are four relational operators in C. They are
Operator Meaning
< Less than
<= Less than or equal to
> Greater than
>= Greater than equal to

C Programming asutoshstat@gmail.com
 3

The associativity of these operators is left to right. Closely associated with the relational
operators are the following two equality operators
Operator Meaning
== Equal to
!= Not equal to
These operators also have a left to right associativity.
These six operators are used to form logical expressions, which represent conditions that are
either TRUE or FALSE. The resulting expressions will be of type integer, since TRUE is
represented by the integer value 1 and FALSE is represented by the value 0.
Example: Suppose 𝑖, 𝑗, 𝑘 are integer variables whose values are 1, 2 and 3, respectively. Some
logical expressions involving these variables are shown below:
Expression Interpretation Value
𝑖<𝑗 TRUE 1
𝑘! = 3 FALSE 0
𝑖 == 𝑘 FALSE 0

Logical Operators
C has the following three logical operators:
Operator Meaning
&& and
|| or
! not
The logical operators act upon operands that are themselves logical expressions. For example,
𝑥 > 0 && 𝑥 < 10. The net effect is to combine the individual logical expressions into more
complex conditions that are either TRUE or FALSE. The result of a logical and (&&) operation
will be TRUE only if both operands are TRUE, whereas the result of a logical or (||) operation
will be TRUE if either operand is TRUE or if both operands are TRUE.

Assignment Operators
There are several different assignment operators in C. All of them are used to form assignment
expressions, which assign the value of an expression to an identifier.
The most commonly used assignment operator is =. Assignment expressions that make use of
this operator are written in the form
identifier = expression;
where identifier generally represents a variable, and expression represents a constant, a variable
or a more complex expression.
Example:

C Programming asutoshstat@gmail.com
 4

x = 3;
sum = x + y;
area = length * width;

Note: The assignment operator = and the equality operator == are distinctly different. The
assignment operator is used to assign a value to an identifier, whereas the equality operator is
used to determine if two expressions have the same value.
Multiple assignments of the form
identifier1 = identifier2 = … = expression;
are permissible in C.

Example: Suppose that i and j are integer variables. The multiple assignment expression
𝑖 = 𝑗 = 5;
will cause the integer value 5 to be assigned to both i and j.

C contain the following five additional assignment operators:

+=, -=, *=, /= and %=.
To see how they are used, consider the first operator +=. The assignment expression
𝑥+= 3;
is equivalent to
𝑥 = 𝑥 + 3;
Similarly, the assignment expression
𝑦−= 1;
is equivalent to
𝑦 = 𝑦 − 1;
and so on for all five operators.

Increment and Decrement Operators

C allows two very useful operators not generally found in other languages. These are increment
and decrement operators:
++ and --

C Programming asutoshstat@gmail.com
 5

The operator ++ adds 1 to the operand, while -- subtracts 1. Both are unary operators (a class
of operators that act upon a single operand to produce a new value) and takes the following
form:
i++; i--;
i++; is equivalent to i=i+1; (or i+=1)
i--; is equivalent to i=i-1; (or i-=1)

Precedence of Operators
The operators within C are grouped hierarchically according to their precedence (i.e., order of
evaluation). Operations with a higher precedence are carried out before operations having a
lower precedence. The operators of the same precedence are evaluated either from left to right
or from right to left, depending on the level. This is known as the associativity property of an
operator.
Among the arithmetic operators *, / and % fall into one precedence group, and + and – fall into
another. The first group has a higher precedence than the second. Thus multiplication, division
and remainder operations will be carried out before addition and subtraction. Within each of
the precedence groups described above, the associativity is left to right. In other words,
consecutive addition and subtraction operations are carried out from left to right, as are
consecutive multiplication, division and remainder operations.
Example: The arithmetic expression
𝑎 − 𝑏/𝑐 ∗ 𝑑
Is equivalent to the algebraic formula 𝑎 − ((𝑏/𝑐) ∗ 𝑑).
Note: The division is carried out first, since this operation has a higher precedence than
subtraction. The resulting quotient is then multiplied, because of left to right associativity.
The natural precedence of operations can be altered through the use of parantheses, thus
allowing the arithmetic operations within an expression to be carried out in any desired order.
In fact, parantheses can be nested, one pair within another. In such cases the innermost
operations are carried out first, then the next innermost operations, and so on.
The following table shows the precedence of operators and their associativity:
Operator Category Operators Associativity
Arithmetic multiply, divide and remainder */ % 𝐿→𝑅
Arithmetic add and subtract + - 𝐿→𝑅
Relational operators < <= > >= 𝐿→𝑅
Equality operators == != 𝐿→𝑅
Logical and && 𝐿→𝑅
Logical or || 𝐿→𝑅
Assignment operators = += -= *= /= %= 𝑅→𝐿

C Programming asutoshstat@gmail.com
 6

Implicit and Explicit Type Conversions in Expressions

When operands of different data types are used in an arithmetic expression, one of the operand
type will be converted to the type of other operand. This conversion takes place automatically
during program execution and is referred to as implicit conversion. The order of conversion
is as follows:
char  int  long int  float  double
Example:
int a = 15;
float b = 3.1, c;
c = a * b;
The result obtained by mixing float and int in the above expression is float which is
assigned to c.

Cast operation is used to overcome automatic conversion. The variable declared in specific
data type can be converted into the required data type as shown below.
(type) expression
or
(type) (expression)
This is known as explicit conversion.
Example:
int a = 5;
float b;
b = (float)a/2;
In the above expression the int variable a is converted into float to get the result 2.5; otherwise
the result will be 2.

C Programming asutoshstat@gmail.com