Julia Calculator ( Introduction)

Transcription

1 Julia Calculator ( Introduction) Julia can replicate the basics of a calculator with the standard notations. Binary operators Symbol Example Addition = 4 Substraction 2*3 = 6 Multify * 3*3 = 9 Division / 8/4 = 2 Basics of PEMDAS The standard order of the basic mathematical operations is remembered by many students through the mnemonic PEMDAS, which can be misleading, so we spell it out here: ( P ) First parentheses ( E ) then exponents (or powers) ( MD ) then multiplication or division ( AS ) then addition or subtraction. This has the precedence of multiplication ( MD ) higher than that of subtraction ( AS ), as just mentioned. Applying this, if we have the mathematical expression We know that the subtraction needs to be done before the division, as this is how we interpret this form of division. How to make this happen? The precedence of parentheses is used to force the subtraction before the division, as in (12 10)/2. Without parentheses you get a different answer: (12 10)/2, 12 10/2 (1.0,7.0) Same precedence what to do There is a little more to the story, as we need to understand what happens when we have more then one operation with the same level. For instance, what is 234? Is it 234 or 234.

2 Unlike addition, subtraction is *not associative8 so this really matters. The subtraction operator is left associative meaning the evaluation of 234 is done by 234. The operations are performed in a left to right manner. Most but not all operations are left associative, some are right associative and performed in a right to left manner. right to left It is the order of which operation is done first, not reading from right to left, as one might read Arabic. To see that julia has left associative subtraction, we can just check , (2 3) 4, 2 (3 4) ( 5, 5,3) Not all operations are processed left to right. The power operation, ^, is right associative, as this matches the mathematical usage. For example: 4^3^2, (4^3)^2, 4^(3^2) (262144,4096,262144) What about the case where we have different operations with the same precedence? What happens then? A simple example would be 234? Is this done in a left to right manner as in: (2 + 3) 4 1 Or a right to left manner, as in: 2 + (3 4) 1 And the answer is left to right: Practice Which of the following is a valid julia expression for 3241

3 that uses the least number of parentheses? (3 2)/ 4 1 (3 2) / (4 1) 3 2 / (4 1) Wich of the following is a valid julia expression for 324 that uses the least number of parentheses? 3 * 2 / 4 (3 * 2) / 4 Wich of the following is a valid julia expression for 242 that uses the least number of parentheses? (2 ^ 4) 2 2 ^ (4 2) 2 ^ 4 2 One of these three expressions will produce a different answer, select that one: 2 3 4

4 (2 3) 4 2 (3 4) One of these three expressions will produce a different answer, select that one: (2 3) * 4 2 (3 * 4) 2 3 * 4 Unary operator: the minus sign One of these three expressions will produce a different answer, select that one: (1^2) 1^2 ( 1)^2 Compute the value of Compute the following using julia : Compute the decimal representation of the following using julia :

5 Incorrect Compute the following using julia : Compute the following using julia : Using functions Most all calculators used are not limited to these basic arithmetic operations. So called scientific calculators provide buttons for many of the common mathematical functions, such as exponential, logs, and trigonometric functions. Julia provides these too, of course. There are special functions to perform common powers. For example, the square root function is used as: sqrt(15) This shows how to evaluate a function using its name and parentheses, as in function_name(arguments). Parentheses are also used to group expressions, as would be done to do this using the power notation: 15^(1/2) Additionally, parentheses are also used to make "tuples", a concept we don't pursue here but that is important for programming with julia. The point here is the context of how parentheses are used is important, though for the most part the usage is the same as their dual use in your calculus text. Like sqrt, there is also a cube root function: cbrt(27) 3.0

6 The cbrt and sqrt functions are not exactly the same as using ^, as they differ when the inputs are not in their domain: For cube roots, we can see that there is a difference with negative bases: cbrt( 8) ## correct 2.0 ( 8)^(1/3) ## need first parentheses, why? DomainError() (The latter is an error as the power function has an output type that depends on the power being real, not a specific value of a real. For 1/2 the above would clearly be an error, so then for 1/3 julia makes this an error.) trigonometric functions The basic trigonometric functions in julia work with radians: sin(pi/4) cos(pi/3) But students think in degrees. What to do? Well, you can always convert via the ratio π180: sin(45 * pi/180) cos(60 * pi/180) However, julia provides the student friendly functions sind, cosd, and tand to work directly with degrees: sind(45) cosd(45) Be careful, an expression like cos2π4 is a shorthand for squaring the output of the cosine of π4, hence is expressed with cos(pi/4)^2 # not cos^2(pi/4)!!!

7 Inverse trigonometric function The math notation sin1x is also a source of confusion. This is not a power, rather it indicates an inverse function, in this case the arcsine. The arcsine function is written asin in julia. For certain values, the arcsine and sine function are inverses: asin(sin(0.1)) 0.1 However, this isn't true for all values of x, as sinx is not monotonic everywhere. In particular, the above won't work for x values outside π2π2: asin(sin(100)) Other inverse trigonometric functions are acos, atan and for completeness asec, acsc, and acot are available for use. Exponential and logs The values ex can be computed with the built in constant e : e^ Or through the function exp(x) : exp(2) As, e can be redefined, it is best to use the latter style, though it takes a bit more typing. The logarithm function, log does log base e: log(exp(2)) 2.0 To do base 10, there is a log10 function: log10(e^2)

8 There is also a log2 function for base 2. However, there are many more possible choices for a base. Rather than create functions for each possible one of interest the log function has an alternative form taking two argument. The first is interpreted as the base, the second the x value. So the above, is also done through: log(10, exp(2)) Some useful functions There are some other useful functions For example, abs for the absolute value, round for rounding, floor for rounding down and ceil for rounding up. Here are some examples round(3.14) 3.0 floor(3.14) 3.0 ceil(3.14) 4.0 The observant eye will notice the answers above are not integers. (We discuss how to tell later.) What to do if you want an integer? These functions have versions iround, ifloor, and iceil to return integer values. (Why this is needed is due to the fact that julia code can run faster when the "type" of a value doesn't change during the calling of a function. So for these functions there are good reasons for the default to keep the same output type as the input value, e.g. floating point to floating point.) Practice What is the value of sinπ10? What is the value of sin52? Is sin1sin3π2 equal to 3π2?

9 yes no What is the value of round(3.5000) What is the value of sqrt(32 12) Which is greater eπ or πe? pi^e e^pi What is the value of πxsinxcosx when x3? Search the page mathematical functions for a function which finds the factorial of n. The proper julia command to find 10 would be: fact(10) factorial(10) 10! Variables With a calculator, one can store values into a memory for later usage. This useful feature with calculators is greatly enhanced with computer languages, where one can bind, or assign, a variable to a value. For example the command x=2 will bind x to the value 2:

10 x = 2 2 So, when we evaluate x^2 4 The value assigned to x is looked up and used to return 4. The word "dynamic" to describe the Julia language refers to the fact that variables can be reassigned and retyped. For example: x = sqrt(2) ## a Float64 now In julia one can have single letter names, or much longer ones, such as some_ridiculously_long_name = 3 3 some_ridiculously_long_name^2 9 The basic tradeoff being: longer names are usually more expressive and easier to remember, whereas short names are simpler to type. To get a list of the currently bound names, the whos function may be called. Not all names are syntactically valid, for example names can't begin with a number or include spaces. In fact, only most objects bound to a name can be arbitrarily redefined. When we discuss functions, we will see that redefining functions can be an issue and new names will need to be used. As such, it often works to stick to come convention for naming: numbers use values like i, j, x, y ; functions like f, g, h, etc. To work with computer languages, it is important to appreciate that the equals sign in the variable assignment is unlike that of mathematics, where often it is used to indicate an equation which may be solved for a value. With the following computer command the right hand expression is evaluated and that value is assigned to the variable. So, x =

11 does not assign the expression to x, but rather the evaluation of that expression, which yields 5. (This also shows that the precedence of the assignment operator is lower than addition, as addition is performed first in the absence of parentheses.) Multiple assignments At the prompt, a simple expression is entered and, when the return key is pressed, evaluated. At times we may want to work with multiple subexpressions. A particular case might be setting different parameters: a=0 b=1 1 Multiple expressions can be more tersely written by separating each expression using a semicolon: a=0; b=1; 1 Note that julia makes this task even easier, as one can do multiple assignments via "tuple destructuring:" a, b = 0, 1 ## printed output is a "tuple" a + b 1 Practice Let a10, b2.3, and c8. Find the value of abac. What is the answer to this computation? a = 3.2; b=2.3 a^b b^a For longer computations, it can be convenient to do them in parts, as this makes it easier to check for mistakes. (You likely do this with your calculator.)

12 For example, to compute pqp1p for p0.25 and q0.2 we might do: p, q = 0.25, 0.2 top = p q bottom = sqrt(p*(1 p)) ans = top/bottom What is the result of the above? Numbers In mathematics, there a many different types of numbers. Familiar ones are integers, rational numbers, and the real numbers. In addition, complex numbers are needed to fully discuss polynomial functions. This is not the case with calculators. Most calculators treat all numbers as floating point numbers an approximation to the real numbers. Not so with julia. Julia has types for many different numbers: Integer, Real, Rational, Complex, and specializations depending on the number of bits that are used, e.g., Int64 and Float64. For the most part there is no need to think about the details, as values are promoted to a common type when used together. However, there are times where one needs to be aware of the distinctions. Integers and floating point numbers In the real number system of mathematics, there are the familiar real numbers and integers. The integers are viewed as a subset of the real numbers. Julia provides types Integer and Real to represent these values. (Actually, the Integer type represents more than one actual storage type, either Int32 or Int64.) These are separate types. The type of an object is returned by typeof(). For example, the integer 1 is simply created by the value 1 : 1 1 The floating point value 1 is specified by using a decimal point:

13 The two values are printed differently integers never have a decimal point, floating point values always have a decimal point. This emphasizes the fact that the two values 1 and 1.0 are not the same they are stored differently, they print differently, and can give different answers. In most cases but not all uses they can be used interchangeably. For example, we can add the two: This gives back the floating point value 2.0. First the integer and floating point value are promoted to a common type (floating point in this case) and then added. Powers are different. This value will be an error 10^( 2), but 10.0^( 2) will not. In base julia, if possible, functions are type stable. This means, the type of the output depends on the type of the input not the value. In this case, integer powers and bases are expected to return integer answers, which 102 is not. When a computer is used to represent numeric values there are limitations: a computer only assigns a finite number of bits for a value. This works great in most cases, but since there are infinitely many numbers, not all possible numbers can be represented on the computer. The first limitation is numbers can not be arbitrarily large. Take for instance a 64 bit integer. A bit is just a place in computer memory to hold a 0 or a 1. Basically one bit is used to record the sign of the number and the remaining 63 to represent the numbers. This leaves the following range for such integers 263 to Julia is said to not provide training wheels. This means it doesn't put in checks for integer overflow, as these can slow things down. To see what happens, let just peek: 2^62 2^63 ## about 4.6 * 10^18 ## negative!!! So if working with really large values, one must be mindful of the difference or your bike might crash! Gotchas Look at the output of 2^3^4 0

14 Why is it 0? The value of 3481 is bigger than 63, so 281 will overflow. The following works though: 2.0 ^ 3 ^ e24 This is because the value 2.0 will use floating point arithmetic which has a much wider range of values. (The julia documentation sends you to this interesting blog post johndcook, which indicates the largest floating point value is which is roughly 1.8e308. Scientific notation is used to represent many numbers A number in julia may be represented in scientific notation. The basic canonical form is a10b, with 10a10 and b is an integer. This is written in julia as aeb where e is used to separate the value from the exponent. The value 1.8e308 means Scientific notation makes it very easy to focus on the gross size of a number, as the exponent is set off. The second limitation is numbers are often only an approximation. This means expressions which are mathematically true, need not be true once approximated on the computer. For example, 2 is an irrational number, that is, its decimal representation does not repeat the way a rational number does. Hence it is impossible to store on the computer an exact representation, at some level there is a truncation or round off. This will show up when you try something like: 2 sqrt(2) * sqrt(2) e 16 That difference of basically 1016 is roughly the machine tolerance when representing a number. (One way to imagine this is mathematically, we have two ways to write the number 1: but on the computer, you can't have the "..." in a decimal expansion it must truncate so instead values round to something like or 1, with nothing in between. Comparing values A typical expression in computer languages is to use == to compare the values on the left and right hand sides. This is not assignment, rather a question. For example: 2 == 2 2 == 3 sqrt(2) * sqrt(2) == 2 ## surprising?

15 false The last one would be surprising were you not paying attention to the last paragraph. Comparisons with == work well for integers and strings, but not with floating point numbers. (For these the isapprox function can be used.) Comparisons do a promotion prior to comparing, so even though these numbers are of different types, the == operation treats them as equal: 1 == 1.0 true The === operator has an even more precise notion of equality: 1 === 1.0 false Scientific notation As mentioned, one can write 3e8 for 3108, but in fact to julia the two values 3e8 and 3*10^8 are not quite the same, as one is stored in floating point, and one as an integer. One can use 3.0 * 10.0^8 to get a floating point equivalent to 3e8. Floating point includes the special values: NaN, Inf. (Not so with integers.) Floating point contains two special values: NaN and Inf to represent "not a number" and "infinity." These arise in some natural cases: 1/0 ## infinity. Also 1/0. Inf 0/0 ## indeterminate NaN These values can come up in unexpected circumstances. For example division by 0 can occur due to round off errors: x = 1e 17 x^2/(1 cos(x)) ## should be about 2 Inf Rational numbers

16 In addition to special classes for integer and floating point values, Julia has a special class for rational numbers, or ratios of integers. To distinguish between regular division and rational numbers, julia has the // symbol to define rational numbers: 1//2 1//2 typeof(1//2) Rational{Int64} As you know, a rational number mn can be reduced to lowest terms by factoring out common factors. Julia does this to store its rational numbers: 2//4 1//2 Rational numbers are used typically to avoid round off error when using floating point values. This is easy to do, as julia will convert them when needed: 1//2 5//2 ## still a rational 1//2 sqrt(5)/2 ## now a floating point However, we can't do the following, as the numerator would be non integer when trying to make the rational number: (1 sqrt(5)) // 2 MethodError(//,( ,2)) Complex numbers Complex numbers are an extension of the real numbers when the values i1 is added. Complex numbers have two terms: a real and imaginary part. They are typically written as abi, though the polar form reiθ is also used. The complex numbers have the usual arithmetic operations defined for them. In Julia a complex number may be constructed by the Complex function: z = Complex(1,2) 1 + 2im

17 We see that julia uses im (and not i ) for the i. It can be more direct to just use this value in constructing complex numbers: z = 1 + 2im 1 + 2im Here we see that the usual operations can be done: z^2, 1/z, conj(z) ( 3 + 4im, im,1 2im) The value of i comes from taking the square root of 1. This is almost true in julia, but not quite. As the sqrt function will return a real value for any real input, directly trying sqrt( 1.0) will give a DomainError, as in 1.0 is not in the domain of the function. However, the sqrt function will return complex numbers for complex inputs. So we have: sqrt( im) im Complex numbers have a big role to play in higher level mathematics. In calculus, they primarily occur as roots of polynomial equation. Practice question Compute the value of using 2.0 not the integer 2 : Inf e308 Domain Error question The result of sqrt(16) is A rational number (fraction)

18 A floating point number An integer question The result of 16^2` is A rational number (fraction) An integer A floating point number question The result of 1/2 is An integer A rational number (fraction) A floating point number question The result of 2/1 is A rational number (fraction) An integer A floating point number question Which number is 1.23e4?

19 question Which number is 43e 2? question What is the answer to the following: val = round( ); question If you need more bits, julia provides the BigInt and BigFloat classes which give 256 bits of precision. Using this allows one to compute 2^3^4 2^3^4precisely as an integer: x = BigInt(2) ans = x^3^4 What is the answer? e