Executable Part
•	This is an important part of a program
•	This is a list of statements executed by the machine
•	The statements are of two kinds:
–	Those perform operations on the variables
–	control statements: specify the sequence of statement execution
•	The operations are determined by the types of variables operated upon.
•	A programming language provide a rich set of data types for representation of information and manipulation
•	It also provides a rich set of control statements 

Program Operations
•	Programs discussed so far have three basic operations and control flow

–		Assignment
–		Expression Evaluation
–		Reading and Writing
–		Sequential Flow of Control

Assignment
•	Specified by assignment statement, eg.
		      Prod = x * y
		      Tot = Tot + hours * 60 * 60

•	It has two parts:
–		A LHS which is usually a variable
–		A RHS which is, in general, a mathematical expression

Expressions
•	Expressions typically appear on the RHS
•	Fortran Expressions remarkably close to std. Math. expressions common in scientific domain
•	Major high level feature introduced by early Fortran that gives its the name Fortran (Formula Translation)
•	Expressions typically involve variables, constants and operators, eg.
		(Principle * Year * Rate) /100    
                                       (arithmetic expressions)
		"Mr." name // initial // sur_name   
                                          (character expressions)
•	100, Mr are Integer and character constants - called Literals
Expression Types
•	Variables are typed 
•	Data types specify operators that operate on the data  values eg.
–		  REAL specifies +, *(multiplication), /  (division),
		                        * * (exponentiation), - (minus)
–	    CHARACTER allows  // (concatenation)

•	Only these operators can appear in expressions

•	Expressions evaluate to a value of definite data type, eg.
        first expression above is REAL , 
        second is CHARACTER type
Type Conformance
•	LHS variable has a type
•	RHS expression
–	involve operations defined by the types of variables on the    RHS also has a type, eg. 
•	Type of x+y  is REAL (or INTEGER)
         when the types of x,y are REAL (INTEGER)

•	In general, types of LHS variable and the value of the RHS expression should be the same

•	This restriction  relaxed among the group of  numeric types (Real, Integer). 

•	More on this later
Execution 
•	Execution of an assignments consists of the following steps:

–	Evaluate the RHS expression to get a value

–	Assign (i.e., store) the value of this expression to the 
	(the corresponding memory location of) the LHS variable.

Evaluation
•	It is similar to mathematical expression evaluation
•	Any variable in an expression stands for the value stored in the corresponding location
•	Operations are performed on these values
•	Complex control flow is abstracted in an expression
•	Use of parenthesis and implicit precedence rules 
•	More on this later
Assignment
•	Assignment updates the memory location corresponding to the lhs variable
•	Variables retain values until updated
•	Stored values in variables are accessed by using the variables on the rhs in later assignment statements
•	Beware!  Two different interpretations for variables
–	Lhs occurrence refers to the memory location
–	Rhs occurrence refers to the value stored

Left and Right Values
•	Consider the statement
            x = x + y
•	The x on the lhs refers to the memory location corresponding to x
•	The x on rhs refers to the value stored in x
•	These two values are referred as lvalues and rvalues
Run-Time Errors
•	Expression evaluation may result in errors
–	Overflow and underflow
–	Divide by zero
•	Evaluation results may be unpredictable
–	Reference to un-initialized variables on the rhs
–	Lhs variable may be undefined
•	So checks have to be made before assignment statement execution
•	Explicit and implicit checks possible 
•	More on this later
Assignment not equal to equality
•	The notation = used for assignment is bad and misleading
•	It resembles conventional equality symbol but different
•	Example:	
                 x = y  and  x = x + y

•	New symbol for new concepts
•	PASCAL is sensible; it uses  :=     for assignment
•	Fortran needs standard equality symbol too  == 
•	more on this later
Arithmetic Expression Evaluation
•	How to evaluate    a * b / c
•	Two possibilities:
–	 a*b and then divide by c or 
–	 b/c and then multiply by a
•	The results are different
•	Unique evaluation order should be specified
•	Use paranthesis, like (a*b)/c or a*(b/c)
•	An implicit order of evaluation, called PRECEDENCE ORDER is assumed using which sub expressions are evaluated in unique order
Precedence Order
•	Operators are assigned a precedence
•	Higher precedence operators are evaluated before lower ones
•	Given an expression, the precedence suggests the following evaluation order:
•	First paranthesized sub expressions are evaluated
–	if more than one, evaluation proceeds from left to right
–	if one nested inside another, then innermost first

                   **, exponentiation (right to left)
                   * and / (left to right)
                    unary + and unary –
                    + and -- (left to right)
Precedence Order (Example)
•	Evaluation of  i  +  j  /  k  * *  2  * (3 - m)
–	expression in brackets evaluated first  (3-m)
–	exponentiation next  (k ** 2)
–	division, multiplication  ((j / (k**2)) * (3-m))
–	additions and subtractions

•	expression equivalent to
              (i  + (( j / ( k ** 2) ) * (3-m)))

•	put brackets to clarify evaluation order

•	redundant brackets do not harm
Mixing Integers and Reals
•	Arithmetic expressions may involve both real and integer variables
•	integer variables and sub expressions are converted to real,eg.
          in (x + i), where x is  real and i integer variable,
          first i is converted to real and added to x
•	conversion involves change of internal representation
•	In x = e, where x is a real variable and e is an integer expression, the integer value of e is converted to real before assigning to x 
•	If x is integer and e is real then the real value is converted to integer and assigned to x
•	Real to integer can cause overflows
Explicit Conversion
•	The conversion above is implicit and cause surprise

•	Better not to mix integer and reals

•	If cannot be avoided, use explicit conversions

•	Fortran provides a lot of intrinsic functions for explicit conversions
Intrinsic Functions
•	real(e)
–	value of integer expression e changed to real form
–	real(e) is an expression of type real

•	int(e)
–	value of real expression e changed to integer
–	fractional part is ignored

•	nint(e)
–	same as int except that real is converted to the nearest integer
Intrinsic Functions
•	floor(e)
–	largest integer <= value of e, which is real

•	ceiling(e)
–	smallest integer >= value of e

•	anint(e)
–	real converted to nearest integer in real form
–	same as real(nint(e))
Functions in Expressions
•	Such functions can appear in expressions

•	eg. x + real(i), i * ceiling (r)

•	such functions have the highest precedence

•	arguments evaluated first and then the functions
READ and PRINT Statements
•	READ statements reads value of variables from a file or keyboard
•	PRINT statements outputs the values of specified variables to the printer or a file
•	Every print statement prints the output in a fresh line
•	typical examples are:
		READ *, Temperature, Pressure
		PRINT *, Volume, Time
•	 The * in both refer to default I/O devices, namely keyboard and printer respectively
•	The * also refers to a certain default format for printing
•	How to override the default settings?
•	will see later
Sequential Control Flow
•	Programs seen so far contained one or more assignment statements and READ and PRINT statements

•	Each statement appears in a fresh line

•	Assignment, READ/PRINT statements direct the control to flow to the following statement.

•	Hence these statements are executed in the order in which present

•	Order is important; result may vary if order is changed

•	There are statements which change the normal sequential flow which we will see later