# This worksheet contains the Maple commands from Chapter 2 of
# Introduction to Scientific Programming by Joseph L. Zachary.
#
# (2.1) The simplest kind of a expression is a number. It evaluates to
# itself.
#
> 57.8;
#
# (2.2) This ill-formed number is an example of a syntax error. Since
# Maple cannot make sense of it, it reports an error.
#
> 5.7.8;
# (2.3) Here we compute the quotient of two rational numbers. Notice
# that the answer is expressed as an exact fraction in lowest terms.
#
> 57800000 / 5761000000;
#
# (2.4) We do the same computation as in (2.3), but this time using
# floating-point numbers. We know these are floating-point numbers
# because they contain decimal points. The answer is rounded off to ten
# digits, not counting the leading zero.
#
> 57800000. / 5761000000.;
#
# (2.5) We do the computation from (2.3) and (2.4) one more time, this
# time using scientific notation to write the floating-point numbers.
#
> 57.8e6 / 5.761e9;
#
# (2.6) We illustrate that floating-point arithmetic is not exact by
# multiplying the quotient from the previous example by the divisor.
# The number that we get back is almost, but not exactly, the same as
# the dividend.
#
> .01003298039 * 5.761e9;
#
# (2.7) Here we square a rational number by using the exponentiation
# operator.
#
> 5280^2;
#
# (2.8) This example shows how more than one arithmetic operation can
# be carried out in a single expression. Because all of the numbers
# involved are floating-points, the result is expressed as a rational
# number.
#
> .01003298039 * 27878400.;
#
# (2.9) We repeat the computation from (2.8) using rational numbers.
#
> 289/28805 * 27878400;
#
# (2.10) Here we divide two floating-point numbers (obtaining an
# intermediate floating-point result), square a rational number
# (obtaining an intermediate rational result), and then multiply the two
# intermediate results. Because the final multiplication involves both
# a floating-point number and a rational number, the rational number is
# first converted to floating-point form.
#
> (57.8e6 / 5.761e9) * (5280^2);
#
# (2.11) This is an example of the use of the sqrt built-in function.
# It returns the square root of its parameter.
#
> sqrt(279703.4405);
#
# (2.12) The parameter to sqrt can be an arbitrary expression. Here we
# take the square root of the value of an expression that involves
# division, exponentiation, and multiplication.
#
> sqrt((57.8e6 / 5.761e9) * (5280.^2));
#
# (2.13) Here we take the same square root as in (2.12), but we use
# rational numbers. An exact result is given using a radical.
#
> sqrt((57800000 / 5761000000) * (5280^2));
#
# (2.14) The evalf built-in function converts a rational number into
# floating-point form.
#
> evalf(17952/5761 * sqrt(28805));
#
# (2.15) There is a limit on the sizes of rational numbers that can be
# computed. Although the limit varies from computer to computer, this
# expression will probably exceed the limit on your computer.
#
> 10^600000;
#
# (2.16) If 10e300000 and 10e(-300000) are acceptable rational numbers
# on your computer, this expression will evaluate to 1.
#
> 10^300000 * 10^(-300000);
#
# (2.17) This expression, however, should cause an overflow.
#
> 10^(-300000) * 10^(-300000);
#
# (2.18) This one should cause an overflow also.
#
> 10^300000 * 10^300000;
#
# (2.19) A compound expression will cause an overflow if any of the
# intermediate results cause an overflow. For example, this will
# probably cause an overflow.
#
> (10^524279 * 2) * 10^(-524279);
#
# (2.20) Depending on the limits imposed on rational numbers on your
# computer, this expression may not cause an overflow.
#
> 10^524279 * (2 * 10^(-524279));
#
# (2.21) The limits on floating-point numbers are less restrictive than
# the limits on rational numbers. This probably won't cause an
# overflow.
#
> 10.^600000000.;
#
# (2.22) But this probably will cause an overflow.
#
> 10.^6000000000.;
#
# (2.23) The exact answer to this calculation should be 15241383936,
# but Maple rounds it to ten digits.
#
> 123456.^2.;
#
# (2.24) The evalf function takes an optional second parameter, which
# is the number of digits to include in the floating-point result.
#
> evalf(17952/5761 * sqrt(28805), 15);
>