Introduction to Octave For Engineers and Scientists — Sandeep Nagar Introduction to Octave For Engineers and Scientists Sandeep Nagar Introduction to Octave: For Engineers and Scientists Sandeep Nagar New York, USA ISBN-13 (pbk): 978-1-4842-3200-2 https://doi.org/10.1007/978-1-4842-3201-9 ISBN-13 (electronic): 978-1-4842-3201-9 Library of Congress Control Number: 2017960430 Copyright © 2018 by Sandeep Nagar This work is subject to copyright All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed Trademarked names, logos, and images may appear in this book Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made The publisher makes no warranty, express or implied, with respect to the material contained herein Cover image by Freepik (www.freepik.com) Managing Director: Welmoed Spahr Editorial Director: Todd Green Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Technical Reviewer: Massimo Nardone Coordinating Editor: Mark Powers Copy Editor: Kezia Endsley Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013 Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springer-sbm.com, or visit www.springeronline.com Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc) SSBM Finance Inc is a Delaware corporation For information on translations, please e-mail rights@apress.com, or visit http://www.apress.com/rights-permissions Apress titles may be purchased in bulk for academic, corporate, or promotional use eBook versions and licenses are also available for most titles For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/ 9781484232002 For more detailed information, please visit http://www.apress.com/ source-code Printed on acid-free paper Dedicated to my wife Rashmi and my daughter Aliya Table of Contents About the Author���������������������������������������������������������������������������������xi About the Technical Reviewer�����������������������������������������������������������xiii Acknowledgments������������������������������������������������������������������������������xv Chapter 1: Introduction to Octave�������������������������������������������������������� 1.1Introduction to Numerical Computing�������������������������������������������������������������1 1.2Analytical vs Numerical Schemes������������������������������������������������������������������2 1.3 Tools for Numerical Computation��������������������������������������������������������������������4 1.4 A Brief History of Octave���������������������������������������������������������������������������������5 1.5 Octave vs Other Alternatives��������������������������������������������������������������������������7 1.6 Installation������������������������������������������������������������������������������������������������������8 1.6.1 Mac OSX�������������������������������������������������������������������������������������������������9 1.6.2 Octave on Ubuntu���������������������������������������������������������������������������������10 1.6.3 O ctave on Windows������������������������������������������������������������������������������11 1.6.4 Using Octave Online�����������������������������������������������������������������������������12 1.7 O ctave GUI�����������������������������������������������������������������������������������������������������13 1.8 S ummary������������������������������������������������������������������������������������������������������15 1.9 Bibliography��������������������������������������������������������������������������������������������������15 Chapter 2: Interactive Octave Sessions��������������������������������������������� 17 2.1 Introduction���������������������������������������������������������������������������������������������������17 2.2 Clearing the Screen with the clc( ) Command����������������������������������������������20 2.3 Customizing the Octave Prompt��������������������������������������������������������������������21 2.4 Working with Files�����������������������������������������������������������������������������������������23 v Table of Contents 2.5 Using the Workspace������������������������������������������������������������������������������������25 2.6 Suppressing the Output Display��������������������������������������������������������������������25 2.7 Running an Octave Program from the System Terminal�������������������������������26 2.8 Summary������������������������������������������������������������������������������������������������������26 2.9 Bibliography��������������������������������������������������������������������������������������������������26 Chapter 3: Mathematical Expressions������������������������������������������������27 3.1 Octave and Math�������������������������������������������������������������������������������������������27 3.2 Octave as a Calculator����������������������������������������������������������������������������������28 3.3 Rational Number Approximations�����������������������������������������������������������������32 3.3.1 Predefined Constants���������������������������������������������������������������������������33 3.4 Using Complex Numbers�������������������������������������������������������������������������������34 3.4.1 Defining a Complex Number�����������������������������������������������������������������35 3.4.2 Properties of Complex Numbers�����������������������������������������������������������36 3.4.3 Using Conjugates����������������������������������������������������������������������������������38 3.4.4 Adding and Subtracting Two Complex Numbers�����������������������������������38 3.4.5 Multiplying and Dividing Complex Numbers�����������������������������������������39 3.5 Common Mathematical Functions����������������������������������������������������������������40 3.6 Learning More Mathematical Functions�������������������������������������������������������41 3.7 Using Variables���������������������������������������������������������������������������������������������42 3.7.1 Data Types��������������������������������������������������������������������������������������������44 3.7.2 Floating Point Numbers and Arithmetic������������������������������������������������45 3.7.3 Overflow and Underflow Errors������������������������������������������������������������47 3.7.4 Floating Point Numbers vs Real Numbers�������������������������������������������47 3.7.5 The eps() Function��������������������������������������������������������������������������������48 3.7.6 Naming Conventions for Variables�������������������������������������������������������49 3.7.7 List of Variables������������������������������������������������������������������������������������51 3.7.8 Global and Local Variables��������������������������������������������������������������������51 vi Table of Contents 3.7.9 The clear Function��������������������������������������������������������������������������������52 3.8 Summary������������������������������������������������������������������������������������������������������56 3.9 Bibliographys������������������������������������������������������������������������������������������������56 Chapter 4: Working with Arrays���������������������������������������������������������57 4.1 Introduction���������������������������������������������������������������������������������������������������57 4.2 Arrays and Matrices��������������������������������������������������������������������������������������59 4.3 Arrays as Vectors������������������������������������������������������������������������������������������60 4.3.1 Coordinate Properties and Basic Transformations�������������������������������62 4.4 Higher Dimensional Arrays/Matrices������������������������������������������������������������64 4.5 Operations on Arrays and Vectors�����������������������������������������������������������������68 4.5.1 Matrix Multiplication�����������������������������������������������������������������������������70 4.5.2 Matrix Division and Inverse of a Matrix������������������������������������������������71 4.5.3 Finding Roots for a Set of Linear Equations�����������������������������������������76 4.6 Summary������������������������������������������������������������������������������������������������������79 Chapter 5: Array Properties����������������������������������������������������������������81 5.1 Introduction���������������������������������������������������������������������������������������������������81 5.2 Automatic Creation of Arrays������������������������������������������������������������������������82 5.3 Creating Random Matrices���������������������������������������������������������������������������82 5.3.1 Creating Random Matrices with Integers���������������������������������������������85 5.3.2 Defining Random Numbers from a Set Distribution�����������������������������88 5.4 Automatic Generation of Large Arrays����������������������������������������������������������92 5.4.1 Generating Arrays Using a Rule������������������������������������������������������������93 5.4.2 Creating Linearly Spaced Vectors���������������������������������������������������������94 5.4.3 Creating Logarithmically Spaced Vectors���������������������������������������������96 5.5 Creating Special Matrices�����������������������������������������������������������������������������97 5.5.1 Upper and Lower Triangular Matrix������������������������������������������������������97 5.5.2 Diagonal Matrix������������������������������������������������������������������������������������98 vii Table of Contents 5.5.3 Ones and Zeros Matrices��������������������������������������������������������������������100 5.5.4 Sparse Matrix�������������������������������������������������������������������������������������101 5.6 Manipulating Arrays������������������������������������������������������������������������������������109 5.6.1 Indexing����������������������������������������������������������������������������������������������109 5.6.2 Using Indices to Make New Vector�����������������������������������������������������111 5.6.3 Slicing�������������������������������������������������������������������������������������������������112 5.6.4 Flipping a Matrix���������������������������������������������������������������������������������117 5.6.5 Rotating a Matrix��������������������������������������������������������������������������������118 5.6.6 Reshaping a Matrix�����������������������������������������������������������������������������119 5.6.7 Sorting������������������������������������������������������������������������������������������������119 5.7 Summary����������������������������������������������������������������������������������������������������120 5.8 Bibliography������������������������������������������������������������������������������������������������120 Chapter 6: Plotting����������������������������������������������������������������������������121 6.1 Introduction�������������������������������������������������������������������������������������������������121 6.2 2D Plotting��������������������������������������������������������������������������������������������������122 6.2.1 The plot(x,y) Function�������������������������������������������������������������������������122 6.2.2 The area() Function�����������������������������������������������������������������������������123 6.2.3 The bar(), barh(), and hist() Functions�������������������������������������������������124 6.2.4 Plotting in Polar Coordinates��������������������������������������������������������������132 6.2.5 Logarithmic Plots��������������������������������������������������������������������������������135 6.2.6 Creating 3D Plots��������������������������������������������������������������������������������140 6.3 Summary����������������������������������������������������������������������������������������������������145 Chapter 7: Data Through File Reading and Writing��������������������������147 7.1 Introduction�������������������������������������������������������������������������������������������������147 7.2 File Operations��������������������������������������������������������������������������������������������148 7.2.1 Users��������������������������������������������������������������������������������������������������148 7.2.2 File Path����������������������������������������������������������������������������������������������149 viii Table of Contents 7.2.3 Creating and Saving Files�������������������������������������������������������������������150 7.2.4 Working with Excel Files���������������������������������������������������������������������155 7.3 Accessing Data from the Internet���������������������������������������������������������������158 7.4 Printing and Saving Plots����������������������������������������������������������������������������159 7.4.1 The print Function������������������������������������������������������������������������������159 7.4.2 The saveas Function���������������������������������������������������������������������������160 7.4.3 The orient Function�����������������������������������������������������������������������������160 7.5 Summary����������������������������������������������������������������������������������������������������161 Chapter 8: Functions and Loops�������������������������������������������������������163 8.1 Introduction�������������������������������������������������������������������������������������������������163 8.2 Using Loops������������������������������������������������������������������������������������������������164 8.2.1 The while Loop�����������������������������������������������������������������������������������164 8.2.2 The do-until Loop��������������������������������������������������������������������������������165 8.2.3 The for Loop����������������������������������������������������������������������������������������167 8.2.4 The if-elseif-else Loop������������������������������������������������������������������������168 8.3 Using Functions������������������������������������������������������������������������������������������169 8.3.1 The function Function�������������������������������������������������������������������������169 8.3.2 The inline Function�����������������������������������������������������������������������������172 8.3.3 Anonymous Functions������������������������������������������������������������������������172 8.4 Summary����������������������������������������������������������������������������������������������������174 Chapter 9: Numerical Computing Formalism�����������������������������������175 9.1 Introduction�������������������������������������������������������������������������������������������������175 9.2 Physical Problems���������������������������������������������������������������������������������������176 9.3 Defining a Model�����������������������������������������������������������������������������������������176 9.4 Numerical Approximations��������������������������������������������������������������������������180 9.5 Tolerance�����������������������������������������������������������������������������������������������������180 9.6 Taylor Series������������������������������������������������������������������������������������������������181 ix Table of Contents 9.7 Taylor Polynomials��������������������������������������������������������������������������������������182 9.7.1 Maclaurin Series for sin(x) and cos(x)������������������������������������������������184 9.7.2 Maclaurin Series for ex�����������������������������������������������������������������������191 9.8 Computational Error������������������������������������������������������������������������������������197 9.8.1 Significant Digits��������������������������������������������������������������������������������198 9.9 Challenges in Real Number to Floating Point Number Conversions������������������������������������������������������������������������������������������������199 9.9.1 Overflow���������������������������������������������������������������������������������������������199 9.9.2 Underflow�������������������������������������������������������������������������������������������201 9.10 Converting Real Numbers to Floating Point Numbers�������������������������������202 9.11 Octave Packages���������������������������������������������������������������������������������������203 9.12 Summary��������������������������������������������������������������������������������������������������203 9.13 Bibliography����������������������������������������������������������������������������������������������204 Index�������������������������������������������������������������������������������������������������205 x Chapter Numerical Computing Formalism Since the error drops by orders of magnitude with each new term, the effect can be best seen using a logarithmic plot This can be generated using the semilogy(error,'r*-') command; Figure 9-4 will be generated Figure 9-4. Error in calculating e0.1 with an increasing number of terms It seems that beyond 10 terms, the error flattens out But you shall see that this is an erroneous result, as this graph will depend on the least count of the computing machine How Many Terms You can observe from Figure 9-4 that by increasing the number of terms, you reduce the error by two orders of magnitude when calculating e0.1 But does this trend mean that to achieve true values, you must include number of terms? After all, each time you add a new term, you invest time 195 Chapter Numerical Computing Formalism and energy resources into the computation In general, the Maclaurin Series has the accuracy of an+1 when n terms are used: ea = 1+ a + a2 a3 a4 an + + +¼+ + O ( a n +1 ) (Equation 9-14) ! 3! ! n! Analytically, you can choose n to be any large number, but this cannot be done on a computing machine The reason is explored next Figure 9-4 shows one interesting fact—beyond 10 terms, the error no longer changes by orders of magnitude and instead flattens out This is misleading Each computing machine has limits of storing tiny floating point numbers This can be obtained by issuing the command eps The system on which the program has been run shows the following output You can see that when the error values are very close to eps values, they cannot be stored reliably The command error(9:12) outputs a similar viewpoint While the ninth term yields an error in the order of 10-15, the eleventh terms onward have similar values in the order 10-16 The computer avoids crashing the calculation by going beyond its limits, which are defined by the eps value 1 >> error(9:12) 2 ans = 4 3.10862446895044e-15 4.44089209850063e-16 4.44089209850063e-16 4.44089209850063e-16 5 >>> eps 6 ans = 2.22044604925031e-16 The command eps gives the machine precision The command help('eps') shows the documentation for the eps command and its usage Technically, eps is the relative spacing between any two adjacent numbers in the machine’s floating point system, i.e., these computational machines least count This number is obviously system dependent, as you could 196 Chapter Numerical Computing Formalism devise specialized hardware where machine precision can be enhanced In fact, this is done for cases where increased precision really matters, such as for missile guidance, space navigation, etc On machines that support IEEE floating point arithmetic, eps is approximately 2.2204 x 10-16 for double precision and 1.1921´10 -7 for single precision It is interesting to know that -52 » 2.2204 ´10 -16 essentially signifies that the double precision mode of the software can store 52 digits after the decimal point The realmax, realmin, intmax, and intmin commands show the maximum and minimum values of real numbers and integers on the particular machine where the software is installed 1 >> realmax 2 ans = 1.79769313486232e+308 3 >> intmax 4 ans = 2147483647 5 >> realmin 6 ans = 2.22507385850720e-308 7 >> intmin 8 ans = -2147483648 It is useful to know these numbers, as any numbers beyond these limits will be prone to error due to machine precision 9.8 Computational Error You have learned about the inherent errors due to the inclusion of certain numbers of terms while calculating a mathematical function There is another kind of error as well, which is introduced due to the fact that computers can store numbers of finite lengths 197 Chapter Numerical Computing Formalism 9.8.1 Significant Digits The concept of significant digits plays an important role here If computers can store all the significant digits of the final answer, then the errors become irrelevant Otherwise, it is important to identify them and if possible rectify them when reporting a final solution For example, while dealing with pi, if only three significant digits are desired, it can be stored easily on any low-end computing solution Computers can store numbers as floating point objects A floating point object stores a number as follows: ± d1d2 ¼ds ´ b e (Equation 9-15) Where di = ,1,2¼b - but d1 ≠ and m ≤ e ≤ M where m Ỵ I - and M Ỵ I + The three parts of a floating point number are as follows: • Sign ( ± ) • Mantissa (d1d2…ds) • Exponent (β) Each part is stored in its own separate fixed-width storage space Based on the IEEE double precision roundoff, MATLAB uses binary arithmetic, whereby: • b =2 • s = 53 • m = -1074 • M = +1023 Since humans are used to decimal arithmetic systems, these binary numbers are converted to decimal numbers for reporting purposes It is important to understand this key point—all internal calculations are done 198 Chapter Numerical Computing Formalism in binary form but input and output is in decimal form The rounding-off error due to these conversions is given by the unit roundoff u, which is the maximum relative error while approximating a real number as a floating point number MATLAB can handle numbers with absolute values from -1074 10 -324 and -1023 10 308 with a unit roundoff u = -53 10 -16 9.9 Challenges in Real Number to Floating Point Number Conversions A real number x can be stored in a floating point representation given by Equation 9-15 as follows: x = ± d1d2 ¼ds ds +1 ¼´10e (Equation 9-16) Note that s = 53, but the previous description does not limit the representation of the floating point number Its storage is an altogether different story When it is stored, the number is rounded off and stored based on the guidelines—s = 53 in this case 9.9.1 Overflow From Equations 9-15 and 9-16, if e > M, computation is said to have overflowed, i.e., a number bigger than the possible storage has been presented and hence the storage container has overflowed In this case, MATLAB produces Inf or -Inf as the answer, which represents the fact that the answer is a very large number The following exercise, performed in a MATLAB terminal, illustrates the process clearly Inf is displayed as an answer when e900 is attempted When this number is divided by a negative number, -Inf is displayed, signifying an overflow while storing a negative number When Inf-Inf is attempted, NaN is displayed, signifying that the large numbers cannot produce a meaningful result 199 Chapter Numerical Computing Formalism 1 >> format long 2 >> exp(50) 3 4 ans = 5 6 5.184705528587072e+21 7 8 >> exp(100) 9 10 ans = 11 12 2.688117141816136e+43 13 14 >> exp(500) 15 16 ans = 17 18 1.403592217852837e+217 19 20 >> exp(700) 21 22 ans = 23 24 1.014232054735005e+304 25 26 >> exp(900) 27 28 ans = 29 30 Inf 31 200 Chapter Numerical Computing Formalism 32 >> exp(900)/-2 33 34 ans = 35 36 -Inf 37 38 >> exp(900)-exp(900) 39 40 ans = 41 42 NaN 9.9.2 Underflow If e < m, then underflow has occurred Octave represents underflow by showing zero as an answer You might think that that underflow is not serious, but consider the fact that, based on the basic rules of exponentiation: e ae-a = e a-a = e0 = When you perform the same calculations for numbers representing overflow and underflow, Octave has to perform Inf X 0, which results in NaN This is demonstrated in this example: 1 >> exp(900)*exp(-900) 2 3 ans = 4 5 NaN 6 7 >> exp(900) 8 201 Chapter Numerical Computing Formalism 9 ans = 10 11 Inf 12 13 >> exp(-900) 14 15 ans = 16 17 0 9.10 Converting Real Numbers to Floating Point Numbers After understanding the two extreme cases, overflow and underflow, you need to understand the process of real number to floating point number conversion Recall from Equations 9-15 and 9-16 that a real number can be stored with s significant digits, as follows: ± d1d2 ¼ds ´ b e This can be written in floating point notation (for base-10) as: x = ± d1d2 ¼ds ds +1 ¼´10e There are two ways to achieve the conversion: method of truncation and method of rounding off Method of truncation will simply discard all digits after s, i.e., it will produce: 202 x = ± d1d2 ¼ds ´10e (Equation 9-17) Chapter Numerical Computing Formalism On the other hand, the method of rounding off recommends the following process: If ss+1 < then perform truncation and retain the sign of x If ss+1 > then ds is incremented and the truncation is performed Retain the sign of x This seemingly simple scheme has a flaw Suppose for s = 4, you need to round off 2.9345 The answer is 2.934, i.e., the last digit is and it’s simply discarded In a similar fashion when 2.9355 is rounded off, the answer can be written as 2.936, where the last digit is discarded and last-significant-digit is incremented In both cases, only one digit needs to change But suppose you need to round to 2.9999 In this case, the answer comes out to be 3.000, where four numeral values need to be changed 9.11 Octave Packages A number of packages exist to perform numerical computations in a particular scientific domain The reference [1] lists some of these packages You can install a package using this command on the Octave command line: >> pkg install -forge package_name 9.12 Summary Almost all branches of science and engineering require you to perform numerical computation Octave is one of the alternatives to doing so Octave has a library of optimized functions for general computation Also, it has a variety of packages to perform a specialized job This makes it an 203 Chapter Numerical Computing Formalism ideal choice for prototyping a numerical computation problem efficiently This chapter summarized various issues related to the error generated during numerical computation and various methods to obtain their value or order of magnitude These quantities are important to measure since in real life, you will need these values to define the accuracy of the final product This book presented the Octave programming language as an effective alternative to the MATLAB base package Furthermore, additional packages can be associated with the Octave framework to perform calculations from a specific domain With an active community of developers, Octave is flourishing in industry and academia and definitely has a bright future 9.13 Bibliography [1] https://octave.sourceforge.io/ 204 Index A, B Analytical vs numerical schemes, Arrays (dot) operator, 57 linear equations, 76 matrix, 59 division, 75 higher dimension, 64 identities, 73 size() function, 66 square brackets, 57 vectors coordinate properties, 62 division and inverse of matrix, 71 matrix multiplication, 70 operations, 68 row and column vector, 60 transformation, 63 Automatic creation of arrays categories, 82 help() and doc() functions, 81 linearly spaced vectors, 94 linspace() and logspace() arguments, 92 logarithmically spaced vectors, 96 manipulation flip up down, 117 indexing, 109 indices, 111 reshape, 119 rotation, 118 slicing, 112 sort function, 119 matrices, 97 diagonal matrix, 98 ones and zeros, 100 sparse, 101 spconvert() function, 106 spdiags() function, 103 speye() function, 101 sprandsym() function, 105 upper and lower triangular, 97 random matrices, 82 integers, 85 rand() function, 82, 87 random numbers, 81 rule, 93 set distribution rande() function, 88 randg() function, 89 randn() function, 89 random numbers, 88 randp() function, 90 © Sandeep Nagar 2018 S Nagar, Introduction to Octave, https://doi.org/10.1007/978-1-4842-3201-9 205 Index C, D, E clear function, 52 Computational error, 197 decimal arithmetic systems, 198 significant digits, 198 users, 148 Functions, 169 anonymous, 172 definition of, 169 inline, 172 script file, 170 F G File operations data sets, 158 excel files command prompt, 155 opening, reading, and writing data, 157 file path, 149 print and save plots orient function, 160 print function, 159 saveas function, 160 print working directory (PWD), 149 requirements, 147 save and load commands binary file, 154 creation, 150 csvread and csvwrite functions, 154 diary command, 152 freport() prints, 153 help save and help load commands, 152 multiple variables, 151 opening and closing files, 153 Garbage In Garbage Out (GIGO), 175 Graphic User Interface (GUI), 13 206 H Homebrew, 9–10 I, J, K Interactive environment, Interactive session, 17 clc() command, 20 disp() function, 24 doc() function, 19–20 evaluation of, 18 files, 23 helloagain.m file, 23 help() function, 19 output display, 25 programming language, 17 terminal programs, 26 unique command prompt, 21 variable, 25 workspace, 25 Inverse-trigonometric functions, 40 Index L Loops, 164 do-until loop, 165 for loop, 167 if-elseif-else loop, 168 while loop, 164 M Mac OSX, Homebrew, 10 Octave logo, package, Mathematical expressions comma (,) operator, 43 built-in function, 40 calculator data types, 29 division, 29 expressions, 29 format() function, 30 format (short/long), 31 inline function, 30 long command, 30 operator, 28 scientific notation, 30 short command, 31 * symbol, 29 clear function, 52 complex numbers addition and subtraction, 38 complex() function, 35 complex plane, 37 computation, 34 conjugates, 38 definition, 35 multiplication and division, 39 properties, 36 real() and imag() functions, 35 data types, 44 definition, 27 eps() function, 48 floating-point numbers definition, 45 radix point, 45 real numbers vs., 47 store numbers, 46 help() command, 41 overflow and underflow errors, 47 rational number approximations, 32 predefined constants, 33 rat() function, 32 strings, 43 variables, 42 global and local variables, 51 list of, 51 naming conventions, 49 Matrices, 59 MATrix LABoratory (MATLAB), 2, 5, 79 Modeling definition, 176 equations, 178 207 Index area() function, 123 bar chart, 124 histogram, 126–128 horizontal bar chart, 125 multiple plots, 128 plot(x,y) function, 122 separate multiple plots, 130 features, 121 polar coordinates CoordinatesPolar.m file, 132 graph, 133 logarithmic scale, 135 pie() function, 137 rose() function, 134–135 semilogx() function, 136 stairs() function, 139 stem() function, 140 Modeling (cont.) functions, 177 mathematical concepts, 178 matrix algebra, 178 Newton’s law, 178 solvers, 179 N, O Numerical computations, 1, 175 vs analytical schemes, approximations, 180 definition, GUI, 13 history of, installation, Mac OSX (see Mac OSX) Octave vs alternative, online, 12 packages, 203 tools of, Ubuntu, 10 Windows, 11 P, Q Personal Package Archive (PPA), 10 Physical system See Modeling Plotting 3D meshing, 141 3D plots, 140 meshc function, 143 mesh function, 140 surf() function, 144 2D plotting 208 R Real number and floating point representation, 199 method of truncation, 202 method of rounding off, 202 number conversion, 202 overflow, 199 underflow, 201 S Scientific computation, Sparse matrix, 101 Index T Taylor polynomials definition, 182 double precision mode, 197 Maclaurin series for ex, 191 Maclaurin series for sin(x) and cos(x), 184 number of terms, 195 Taylor series, 181 Tolerance limit, 180 Trigonometric functions, 40 U, V, W, X, Y, Z Ubuntu, 10 command-line interface, 11 PPA, 10 209 .. .Introduction to Octave For Engineers and Scientists Sandeep Nagar Introduction to Octave: For Engineers and Scientists Sandeep Nagar New York, USA ISBN-13 (pbk):... be used to customize the Octave prompt to any desired string For example, suppose you want to use octave> > as the Octave command prompt You simply type the following command: 1 >> PS1( "Octave> >")... perform those calculations using Octave For example, Octave at present cannot perform bra and ket operator-based calculations for quantum mechanics Let’s start probing Octave? ??s abilities to perform