COMPUTER SCIENCE & ENGINEERING DEPARTMENT Harmattan Semester, 2013/2014 Session. CSC 307: Numerical Computations I [PRACTICAL LAB ONE]

Transcription

1 ỌBÁFÉ. MI AWÓLÓ. WÒ. UNIVERSITY COMPUTER SCIENCE & ENGINEERING DEPARTMENT Harmattan Semester, 2013/2014 Session. CSC 307: Numerical Computations I [PRACTICAL LAB ONE] ỌDÉ. JỌBÍ Ọdé.túnjí Àjàdí THIS DOCUMENT IS NOT FOR SALE! Contents 1 Introduction Background to the laboratory Purpose of the laboratory Programming Why Fortran Why Octave Laboratory reports Assignment submission dates Programming work Laboratory Assignment I EXPERIMENT I: Error and Error Propagation Machine epsilon Task set Machine Gamma Task set Precision of computation data Task set Laboratory Assignment II Task 01: Canonical Polynomials Task 02: Horner s Polynomials Task 03: Root of Polynomials Task 04: Evaluating Function as Polynomials Engineering Application Task 05: Application of Polynomials i

2 1 Introduction This document has been written to guide you during the practical classes. It is important that you are familiar with the contents of this document before coming for your practical classes. As discussed during our lectures, the aim of a study in numerical computations is to acquire skills required for developing effective and accurate solution to numerical problems. The emphasis in our practical classes is not merely to obtain an answer or result, but also on knowing the limit and/or context of the application of the obtained results. 1.1 Background to the laboratory The laboratory experiments in this course, among other things, are meant to provide insights into the design of accurate and effective numerical algorithms and their implementation on digital computers. You will be expected to gain experiences on: i. The fundamentals of numerical rendering of problems. ii. Data representation and manipulation on digital computing machines. iii. Numerical algorithm construction methodology. iv. Algorithm implementation as program (Plato Fortran and Octave). v. Error management techniques: detection, reduction or avoidance strategies. vi. Issues in the use of modern numerical software and tools. vii. Hints on numerical software development process. Skill development through practices with programming exercises will provide a background for much of the course work. The programming exercises will focus on the utilization of numerical concepts and methods which have engineering applications. The practical exercises will emphasis good programming style as well as adequate and accurate documentation procedures. 1.2 Purpose of the laboratory The laboratory assignments in this course have four(4) basic goals: 1. They help you to understand the general concepts and principles discussed in CSC 307 course lectures, as well as during your private studies, by allowing you to experiment with and confirm specific concepts expressed in some of the ideas presented. 2. They help to improve your proficiency in algorithm design and computational problem solving. This proficiency will be useful in modelling and simulation of scientific and engineering concepts and systems. 1

3 3. They help you to learn the principles of scientific and engineering experiment documentation. 4. They allow your instructor(s) to evaluate your practical skills in Numerical Computations. Accordingly, you are advised strongly to make sure that all the work which you submit for assessment arise out of your efforts and ideas. You are permitted, and encouraged, to discuss general algorithm design with the course lecturers as well as the laboratory coordinators. You may also receive help with specific debugging problems during the practical sessions from the laboratory coordinators. However, you are expected to work independently, or only within your own team (where applicable), when in the laboratory. 1.3 Programming We will be using a programming language and a programming tool in this course. The program language is Fortran 95 in Plato IDE (Integrated Development Environment). Octave is the programming tool for modelling and simulation. You will ask why we have selected these two platform given the fact that there are more popular programming language such as Java and simulation and modelling software such as MatLab, Mapel and Mathematical. One of the reasons is that programming languages such as Java are designed for witting general-purpose software. They are not developed specifically for engineering and scientific computing as is the case for Fortran. Modelling and simulation tool such as MatLab, Mapel and Mathematical are very expensive and outside our reach. Plato IDE and Octave are open-source software, thus they are freely available for teaching and research. The more technical reasons for our choice are as follows. 1.4 Why Fortran The Fortran (FORmular TRANslation) programming language was originally written for engineering and scientific programming. It therefore provide all the necessary tools and programming structure that will allow us to express and solve engineering and scientific problems. Specifically: 1. It provides greater expressive power: Fortran statements are intuitive to engineers and scientist. 2. It enhances safety (i.e. provide tools for computational errors detection). 3. It enhance regularity since it uses standard syntax (i.e. rule for writing program instruction). 4. It provides extra fundamental features (such as dynamic storage). 5. It exploits modern hardware better. 6. It improve portability between different machine ranges. 2

4 7. It provides better access to computer hardware, than say Java. 8. It produces more efficient codes as Fortran code are compiled not interpreted like Java. In addition, the Plato IDE (Integrated Development Environment) that we will be using in this course is freely available and can be downloaded from the Internet. The IDE is also easy to use as it provides a lot of supporting documents and examples online. The main disadvantage of Fortran is that it was developed before several important advances in modern programming paradigm. This limitation nonetheless, the drill provided by the Fortran programming language platform facilitates the kind of environment suitable for educational development for improving student learning experience. Also, several advance programming features have been added to Fortran in recent times. One of such addition is the object orientation programming concept (This is available in Fortran 2003). 1.5 Why Octave We will be using the Octave platform to plot graphs and write simple simulation programs in this course. Although this tasks could be achieved using Fortran it will take more programming efforts to achieve comparative results. Note that, Fortran will allow us to access some features of computer systems in a manner that modelling as simulation languages such as MatLab or Octave will not. Octave package provides a close compatibility with MatLab. This gives us the opportunity to learn the syntax and power of both packages without financial and/or licence restrictions. 1.6 Laboratory reports The documentation of your experiments is very important and will be given much attention during the grading of your laboratory work. You should, therefore, ensure that your laboratory reports follow the format stated in Table 1. It should include information about your observations as much as possible. Also note that the items listed as 1, 2, 3, 6, 7, 8, and 13 must be included in your reports. Items listed as 5, 9, 10, 11 are important. While items listed as 4 and 12 should be included when used. The presentation of your laboratory report should be clean, clear and legible. 1.7 Assignment submission dates The dates when you will be required to submit the reports of your assignments will be announced during lectures or on the course webpage. You should endeavour to submit your reports on or before twelve noon on such dates. Late submission will attract mark deductions. 3

5 Table 1: Laboratory Document Contents Ser. Item names Item Descriptions No. 1. Name and Title of Report NAME: Numerical Computation, Laboratory One. TITLE: Error And Error Propagation 2. Author and date Your full name(s), Identification numbers, and Department of major (this must be listed for all group members if it is a group work) 3. Table of Contents Tables of Contents List of Figures (If any) List of Tables (If any) 4. Glossary of Notation and Terms List all uncommon symbols and terms and specify their meanings. 5. Introduction Brief discussions, stating the background of the present work. 6. Problem statement Statement of the problem Mathematical models of problem. Supporting theory and physical laws for solution (if and) 7. Objectives of Experiment General Objective(s) of the lab. work Specific Objective to be accomplished in this experiment 8. Experiment procedure Initial setting/material and tools. Experiment processes. Measurement and recording processes. Algorithm design Program development and running. Final setting (if any) 9. Discussion of results Analysis of method used, significance of result obtained. 10. Technological interpretation and Application of results Illustrate, with examples, the real-life interpretation and applications of the result of your experiment. 11. Conclusion and Suggestions Summary and general observation, next for further works course of action. 12. Appendixes Tables of values and results Program listings. 13. References List all the literature cited in your work. 1.8 Programming work You will be require to carry out your programming work inside the laboratory. You may design your algorithms and test your code before coming to the laboratory. You 4

6 may also create the source code and make some corrections by removing errors (debugging). You will, however, be required to explain the procedure and the contents of your program. Familiarity with the contents of your program code and your creativity and ingenuity at problem solving will be reckoned and rewarded accordingly. In the case of a team work, all members of the team must have good understanding of the experiment. The inability of any member of the team to convincingly answer questions related to the laboratory experiment, WILL affect the score of ALL the team members. Documentation on Plato and Octave can be obtained from the Internet. The respective URL will be provided and a pointer to the website to download them is provided on the Computing and Intelligent Systems Research Group webpage If you are having issues with these packages please seek assistance from the laboratory coordinators. 5

7 2 Laboratory Assignment I 2.1 EXPERIMENT I: Error and Error Propagation The aim of most activities in numerical computations is to develop and implement accurate, effective and efficient numerical solution. Therefore, numerical algorithms are design with the almost aim of obtaining an exact result when implemented on a computational tool. The task of minimizing error in a computational process is a relative one which depends on many factors. As discussed during our lectures we can categorise computation errors into three(3) broad type Conceptual: The error arises from faults in the thinking or theory underlying the mathematical models used to express the problems. Inherent: This error arises from limitation in the capacity of the tools and techniques used for solving the problem. They are further grouped as: (i) Mathematical errors; some problem will produce correct result when solved analytically but erroneous result when solved computationally. (ii) Instrument error (a) Measuring instrument error and (b) computing instrument error. Arithmetic: This error arises when arithmetic operation are realised on computing tool. They include: (i) Subtractive Cancellation error or Catastrophic error, (ii) Negligible substation error, (iii) Negligible addition error, (iv) Magnification error and (v) Counter-intuitive arithmetic error. This laboratory we will be focused on the errors inherent in computing instrument. When you sit in the front of a computer for the first time and you wish to solve numerical computing problem on it, you need to determine the smallest (machine epsilon) and largest (machine gamma) real number it can store. This will give you an idea about what scale of problem you can solve with the machine. 2.2 Machine epsilon The machine epsilon (represented using the symbol ɛ) of a computer is the smallest number it can store. Any number smaller than the machine epsilon of a machine will be stored as zero. Determining the epsilon of a machine is critical to the implementation of most numerical algorithms and the interpretation of the results computed on it. Also, the accuracy of real numbers and the results of arithmetic operations on a computer is constrained by its machine epsilon. Algorithms for determining machine epsilon are meant to find the smallest number such that when subtracted from one (1.0) will produce a result smaller than one. That is 1.0 epsilon < 1.0. The next smaller number to epsilon will make 1.0 epsilon = 1.0. A way to compute epsilon is to start with a small number and repeatedly divide it by a small value, say 2.0, until the expression 1.0 epsilon < 1.0 becomes false. The last number that was obtained before this condition is reached is taken as the machine epsilon. The algorithm (pseudo-code) in Table 2 computes the machine epsilon based 6

8 on the process we have just described. Note that subtraction operations was used to realise the computation of epsilon in this algorithm. Table 2: Algorithm: Machine Epsilon (With Subtraction) START: REAL epsilon = 1.0 r := epsilon WHILE (r < 1.0) epsilon = epsilon/2.0 r = epsilon Write epsilon ENDWHILE END: It is the case that we can also use the addition operation to compute the machine epsilon. The algorithm (pseudo-code) in Table 3 computes the machine epsilon using the addition operation. Table 3: Algorithm: Machine Epsilon (With Addition) START: REAL epsilon = 1.0 r := epsilon WHILE (r > 1.0) epsilon = epsilon/2.0 r = epsilon Write epsilon ENDWHILE END: The code in Figure 1 is the Fortran program to implement algorithm design in Table 2. The Octave code in Figure 2 also implements the algorithm design in Table Task set 1 1. Implement the algorithms (pseudo-code) in Tables 2, using the Fortran Plato and Octave environment, respectively. To do this, just reproduce the programs in Figures 1 and 2, respectively. Note that epsilon is defined as single precision data (REAL in Fortran and Short in Octave) in this experiment. 2. Repeat experiment 1 by defining epsilon as DOUBLE PRECISION number by modifying the program in Figures 1 and 2 to compute the machine epsilon in double precision: Use REAL (KIND = 8) to declare double precision in Fortran. In Octave, replace the command in Line 4 with format long. 7

9 Figure 1: Fortran code for computing machine epsilon Figure 2: Octave code for computing machine epsilon 3. Experiment with various division for the epsilon by modifying the line of code corresponding to epsilon := epsilon/2.0 in the algorithm. Use the divisors as 3.0, 5.0, and

10 4. Plot a graph (use Octave plot command) relating the epsilon you obtained against the divisor you used. 5. Repeat exercises 1 through 4 using the algorithm in Table Discuss your observations and results. Note that in Octave, the keyword eps returns the value for the machine epsilon based on an algorithm built into the package. 2.4 Machine Gamma The Machine Gamma (Γ) of a computer is the largest real number that it can correctly store. Any number bigger than the machine Gamma is considered as Not a Numbers and represented as NaNs. The machine Gamma is related to the machine epsilon by Equation 1: ɛ = Γ (1) 2.5 Task set 2 1. Write a program to compute machine Gamma based on the machine epsilon you obtained in Task Discuss your observations and results. The numerical space of the computer is defined by the closed interval [ɛ, Γ]. Any computation that results in values outside this range cannot be handled by the computer and the result is said to be in error. If a computation produces a result smaller than the machine epsilon (i.e. ɛ), the operation is said to have resulted in underflow error. When underflow error occurs, the result of the computation is usually stored as zero. If a computation produces a result bigger than the machine gamma (i.e. Γ), the operation is said to have resulted in overflow error. When overflow error occurs, the result of the computation is usually stored as NaN (Not a Number). NOTE THAT: 1. When format long instruction is used in an Octave program script, all variables are in double precision. The implication of this is that the number of bits reserved for storing the mantissa is increased (perhaps doubled). This has the effect of increasing the precision of the number being processes. This, however, comes at the cost of slower computation. 2. The exact value for machine epsilon or machine gamma on a computer cannot be determined, it can only be estimated. This is because there are many confounding factors influencing the determination of machine epsilon, for example the operating system on the computer, other programs running in the background and so on. 9

11 Figure 3: Machine real number space 2.6 Precision of computation data The accuracy of any real number stored on a computer system depend heavily on the word length of the system. The word length is the number of signal communication lines on the processor s data bus. The data bus is the path through which data signals are transmitted within the computer. A 16-bit computer, for example, has sixteen (16) lines on its data bus and its word length is 16 bit. The more the number of lines on the data bus, the higher the precision of data. In addition to the word length, the format for storing real numbers on the computer can also influence the accuracy of numeric data. Errors related to the limited capability of a computational tool such as this are called inherent error (i.e computing tool inherent error). The representation of real numbers is similar to that used in scientific notations. A real number is represented by Equation 2: Where: M is called the mantissa of the number. β is the base of the number. E is the exponent. F = ±M β ± E (2) The number of bits in M determines the precision of the number. It determines the smallest number that can be represented by the system. Therefore, the more the number of bits that is assigned to the mantissa, the more precise the data that can be stored on the computer system. β is the base of the number. In the case of digital computers, β = 2. Since β is same for all the number that will be stored on a machine, it is generally not store, but implied. The exponent E, determines the magnitude of the number. The number of bit for representing E determines the magnitude of the number that can be store. For example, the decimal number is smaller but more precise than This is because, thee are more digits in the mantissa but the exponent is smaller, i.e. 5 < 10. Generally, the more the number of bits assigned to the mantissa in the floating-point data representation scheme used on a computer, i.e. M, the better the precision of the number stored. The relations between the number of bits in the mantissa, M, and the decimal number of significantly accurate digit (k) is give by the equation: ( ) M k = INT EGER

12 When working with floating point numbers on digital computers, a number of arithmetic errors do occur. Such errors are as a result of the limited capability of the computer. For example, the number 1 3 will produce an infinitely recurring fraction, that is The computer has finite memory, finite processor and finite data paths. Therefore, it is not possible to represent all the digits of an infinite fraction. To store such numbers on a computer, it is necessary to truncate. This truncation, introduces error at many different levels of manipulating the number. It is also important to note that only the addition circuits are implemented at the hardware level of the computer. Other arithmetic operations, that is subtraction, multiplications and division, are achieved through logical algorithms that exploit the addition operation. Such logic usually combine complementation and/or shifting operations with addition. Errors arising from this situation include: 1. Subtractive cancellation: Occurs when subtracting two almost equal numbers. When the result produced is less than the machine epsilon, zero is stored. 2. Negligible addition: Occurs when a very small number is added to a very lager number and the result is the large number. 3. Negligible subtraction: Occurs when a very small number is subtracted from a very lager number and the result is the large number. 4. Magnification error: Occurs when a small number is used to divide a large number or when multiplying two large numbers. Overflow error will usually occur. 5. Counter Intuitive error: The result of an arithmetic operation which is contradictory to arithmetic logic. E.g. when carrying out the subtraction operation A B where A and B are none-zero and positive and the result is bigger A. 2.7 Task set 3 1. Write Fortran Program and Octave codes to demonstrate each of the arithmetic errors. 2. Discuss your observations and results. 3. Repeat experiment 1 and 2 using double precision arithmetic. Note that the single precision data storage and operations are native to a computer. It is possible to extend this precision using data declaration directives. When a variable is declared as double precision (or format long), the mantissa of data format used for storage is doubled. This has the effect of increasing the precision with which the number is represented and processes. This however, comes at the cost of slow computation. 11

13 3 Laboratory Assignment II During our lectures, we have seen that polynomials provide an efficient means of representing some mathematical expressions. We have also seen that most trigonometric, hyperbolic, and exponential functions can be expressed in the form of polynomial. The accurate, efficient and effective evaluation of polynomials are therefore important in the development of computational solution to scientific and engineering problems. A polynomial of degree n is written as: P n (x) = a 0 x 0 + a 1 x 1 + a 2 x 2 +,..., +a (n 1) x (n 1) + a n x n (3) Equation 3 can also be written in the form: P n (x) = n a i x i (4) i=0 Equation 3 and 4 are called the Canonical, Naïve, Series or Sequential form of polynomial expression. The values a i, i = 0, 1, 2,..., n are the parameters of the polynomial and x is the variable (independent). A polynomial of degree one, i.e. n = 1, is called linear (it describes a line function or relation). Polynomials with degree two or more, i.e. when (n 2), are called non-linear functions. Specific names for polynomial commonly used in engineering applications are listed in Table 4. Table 4: Polynomial Nomenclature Degree Name Representation 1 Linear a 0 + a 1 x 2 Quadratic a 0 + a 1 x + a 2 x 2 3 Cubic a 0 + a 1 x + a 2 x 2 + a 3 x 3 4. Quatic a 0 + a 1 x + a 2 x 2 + a 3 x 3 + a 4 x 4 Polynomials are frequently used in engineering problem description, modelling and simulation. This is because they exhibit a number of unique properties which include the following [3, 5, 2, 1, 6, 4]: 1. Polynomials are smooth. 2. Polynomials are easy to store and manipulate on a digital computer. To store polynomials, we only need to store the coefficients (i.e. the a i s) and one variable (i.e. x). To manipulate polynomials we require only basic arithmetic operations of addition (+), subtraction (-) and multiplication (*). 3. The derivative and integral of a polynomial will produce another polynomial whose coefficient can be computed algebraically. 12

14 Figure 4: Illustration of Polynomials 13

15 4. The root of a polynomial can be easily computed using an algorithm. 5. Given a continuous function or a set of values over a closed interval, say [a, b], it is possible to find a polynomial to model or represent it. 6. Most engineering problems can be expressed as a polynomial of suitable degree n. 3.1 Task 01: Canonical Polynomials 1. Using the four types of polynomial in Table 4, show that n(n + 1)/2 multiplications and n additions are needed to compute Equation 3, where n is the degree of the polynomial. 2. Study the pseudo-code in Table 5 and discuss the Design of a solution algorithm for Equation 3 using a flowchart. 3. Write the program to implement the algorithm you designed for Equation 3 using Plato Fortran and Octave. Table 5: Algorithm for canonical polynomial evaluation ================================================== START: " i => Index of the coefficient array. " n => Degree of the polynomial. " a[n] => Array element n, holds the parameters. " x => Polynomial independent variable. " P => The result of the polynomial computations. INTEGER i,n REAL a[n], x, P READ n READ a[i], i = 0, n P = a[0] For i = 1, n P = P + a[i] * xˆi NEXT i WRITE P END: ================================================== 14

16 3.2 Task 02: Horner s Polynomials Another form of expressing Equation 3 is presented in Equation 5. P n (x) = a 0 + x(a 1 + x(a , +x(a n 1 + x(a n )))) (5) Equation 5 is called the Horner s or nested form of polynomial expression. 1. Using the four types of polynomial in Table 4, show that n multiplications and n additions are required to compute Equation 5, where n is the degree of the polynomial.. 2. Study the pseudo-code in Table 6 and discuss the Design of a solution algorithm for Equation 5 using a flowchart. 3. Write the programme to implement the algorithm you designed for Equation 5 using Plato Fortran and Octave. Table 6: Algorithm for Horner s Polynomial Evaluation ================================================== START: " i => Index of the coefficient array. " n => Degree of the polynomial. " a[n] => Array element n, holds the parameters. " x => Polynomial independent variable. " P => The result of the polynomial computations. INTEGER i,n READ n REAL a[n], x, P READ a[i], 0 =1, n P = a[n] For i = 1, n P = P*x + a[n-i] NEXT i WRITE P END: ================================================== 3.3 Task 03: Root of Polynomials Remember also that Equation 3 can be expressed as Equation 6. P n (x) = (x x 0 )(x x 1 )(x x 2 ),..., (x x n 1 )(x x n ) (6) or, in the short form 15

17 P n (x) = n (x x i ) (7) i=0 In Equation 6 and 7, x 0, x 1,..., x n are the roots of the polynomial. A root is a value which when you substitute into an equation, the result will be zero. This value corresponds to the point of stability or equilibrium of the system represented by the polynomial. Equation 7 requires n multiplications and n subtractions. Note that the computational load of the subtraction operation is more than that of addition, usually by a factor of Design the solution algorithm for Equation 6 using flowchart and pseudo-code. 2. Write the programme to implement the algorithm you designed in 1. using Plato Fortran and Octave. Nota that, the programme you developed in Task 3 could be used to explore the root of the system modelled by Equation Task 04: Evaluating Function as Polynomials As stated earlier, the models for most scientific and engineering problems can be expressed in the form of a polynomial. In fact programming languages implement Builtin subprogrames which are used to compute most functions encountered in scientific and engineering problem solving. Such functions are implemented using algorithms based on Taylor series, which are polynomials. 1. Study the functions in Table 7 and confirm their correctness. 2. Design an algorithm to implement each of the functions. Your algorithm should facilitates a computation that takes variable number of terms (i.e. different values of n) in the series. 3. Implement the solution algorithm you designed in 2. using Octave. 4. Study your programme by computing the values of x in the interval [0.0, π 2 ] with step 0.15 for n = 3, 5, 10, 15 and 25. n is the number of terms in the series that is used to compute each equation. Plot the results for each polynomial against x. 5. Using the Octave built-in functions, repeat the experiment in 4. [Note that you do not know the number of terms used in the Octave built-in functions]. 6. Plot your results in 4. and 5. and discuss your observations. Note that the first neglected term in each series is taken to be the error in the series. Polynomials will work well on sufficiently small intervals. When larger intervals are used, however, severe oscillation often appears, particularly when the degree of the polynomial is more that 4. For practical engineering problems therefore, polynomials of degree 4 or less is recommended. If the interval is long, it can be divided up into smaller intervals and separate polynomials used to model each of the smaller pieces of intervals: (This idea is the basis of the Spline interpolation method). 16

18 4 Engineering Application As stated in the previous sections, most scientific and engineering models can be represented using polynomials. Some general problems have been studied and the numerical methods for their theoretical solution using polynomials have been developed. Examples of such polynomials include [7]: Chebychev polynomials, Laguerre polynomials and Hermite polynomials. For example, the second-order differential equation is useful in modelling the behaviour of a number of dynamic systems commonly encountered in engineering. The Laguerre form of such equation is given by x d2 y dy + (1 x) + ny = 0.0 (8) dx2 dx In Equation 8, y is the dependent variable and x is the independent variable and n is a positive integer. The solution to this problem is a set of polynomial, which are orthogonal. Six of the Laguerre polynomials, which solves the model in Equation 8, are as listed in Equations 9 through 14: L 0 (x) = 1.0 (9) L 1 (x) = 1.0 x (10) L 2 (x) = 1 2! (x2 4.0x + 2.0) (11) L 3 (x) = 1 3! ( x3 + 9x x + 6.0) (12) L 4 (x) = 1 4! (x4 16.0x x x ) (13) L 5 (x) = 1 5! ( x x x x x ) (14) 4.1 Task 05: Application of Polynomials 1. Design the algorithm for computing the six Laguerre polynomial Equations. 2. Write a program to implement the algorithm in 1. and plot their values between x = 0.0 to x = 6.0 with step 0.5 using the Octave programming environment. 3. Discuss the accuracy of your results. 17

19 Ser. No. 1. Table 7: Polynomial representation of some functions Function Polynomial expression (n terms) e x x + x2 2! + x3 3! + x4 4! + x5 5!... = n i=0 x i i! cos x sin x sinh x cosh x 1.0 x2 2! + x4 4! x6 6! + x8 8! x10 n 10!... = x x3 3! + x5 5! x7 7! + x9 9! x11 n 11!... = i=0 i=0 ( 1) i x2i 2i! ( 1) i x(2i 1) (2i 1)! x + x3 3! + x5 5! + x7 7! + x9 9! + x11 n 11!... = x (2i 1) (2i 1)! i= x2 2! + x4 4! + x6 6! + x8 8! + x10 n 10! +... = x (2i) (2i)! i= (1.0 x) x + x 2 + x 3 + x 4 + x 5,... = 1.0 ln (1.0 x) x x x x4 +,... = 1.0 (1.0 x n ) x n + x 2n + x 3n + x 4n +,... = n i=0 n i=0 x i i! n i=0 x i x ni 18

20 References [1] J. G. Bronson. Algorithm Development and program design using C, volume 1. West Publishing Company, [2] D. Goldberg. What every computer scientist should know about floating-point arithmetic. Computing Surveys, pages , March [3] Y. Jaluria. Computer Methods for Engineers, volume 1 st. ALLYN and BACON, Inc., Canada, [4] J. Kiusalaas. Numerical Methods in Engineering with MATLAB. Cambridge University Press, United Kingdom, [5] U. Manber. Introduction to Algorithms: A creative approach, volume 1. Addision- Wesley, [6] K. H. Rosen. Discrete Mathematics and Its Application, volume 5 th. McGraw-Hill Higher Education, United States, [7] F. Scheid. Schaum s Outline of Theory and Problems of Numerical Analysis. McGraw-Hill Publishing, New Delhi, 2 nd edition,