/ Linux Reviews / Beginners: Learn Linux / Advanced BashScripting Guide  en
12.8. Math Commands"Doing the
numbers"  factor
Decompose an integer into prime factors. bash$ factor 27417
27417: 3 13 19 37
 bc
Bash can't handle floating point calculations, and
it lacks operators for certain important mathematical
functions. Fortunately, bc comes to
the rescue. Not just a versatile, arbitrary precision calculation
utility, bc offers many of the facilities of
a programming language. bc has a syntax vaguely resembling C. Since it is a fairly wellbehaved UNIX utility, and may
therefore be used in a pipe,
bc comes in handy in scripts. Here is a simple template for using
bc to calculate a script
variable. This uses command
substitution. variable=$(echo "OPTIONS; OPERATIONS"  bc)
Example 1240. Monthly Payment on a Mortgage #!/bin/bash
# monthlypmt.sh: Calculates monthly payment on a mortgage.
# This is a modification of code in the "mcalc" (mortgage calculator) package,
#+ by Jeff Schmidt and Mendel Cooper (yours truly, the author of this document).
# http://www.ibiblio.org/pub/Linux/apps/financial/mcalc1.6.tar.gz [15k]
echo
echo "Given the principal, interest rate, and term of a mortgage,"
echo "calculate the monthly payment."
bottom=1.0
echo
echo n "Enter principal (no commas) "
read principal
echo n "Enter interest rate (percent) " # If 12%, enter "12", not ".12".
read interest_r
echo n "Enter term (months) "
read term
interest_r=$(echo "scale=9; $interest_r/100.0"  bc) # Convert to decimal.
# "scale" determines how many decimal places.
interest_rate=$(echo "scale=9; $interest_r/12 + 1.0"  bc)
top=$(echo "scale=9; $principal*$interest_rate^$term"  bc)
echo; echo "Please be patient. This may take a while."
let "months = $term  1"
# ====================================================================
for ((x=$months; x > 0; x))
do
bot=$(echo "scale=9; $interest_rate^$x"  bc)
bottom=$(echo "scale=9; $bottom+$bot"  bc)
# bottom = $(($bottom + $bot"))
done
# 
# Rick Boivie pointed out a more efficient implementation
#+ of the above loop, which decreases computation time by 2/3.
# for ((x=1; x <= $months; x++))
# do
# bottom=$(echo "scale=9; $bottom * $interest_rate + 1"  bc)
# done
# And then he came up with an even more efficient alternative,
#+ one that cuts down the run time by about 95%!
# bottom=`{
# echo "scale=9; bottom=$bottom; interest_rate=$interest_rate"
# for ((x=1; x <= $months; x++))
# do
# echo 'bottom = bottom * interest_rate + 1'
# done
# echo 'bottom'
# }  bc` # Embeds a 'for loop' within command substitution.
# ====================================================================
# let "payment = $top/$bottom"
payment=$(echo "scale=2; $top/$bottom"  bc)
# Use two decimal places for dollars and cents.
echo
echo "monthly payment = \$$payment" # Echo a dollar sign in front of amount.
echo
exit 0
# Exercises:
# 1) Filter input to permit commas in principal amount.
# 2) Filter input to permit interest to be entered as percent or decimal.
# 3) If you are really ambitious,
# expand this script to print complete amortization tables. Example 1241. Base Conversion #!/bin/bash
##########################################################################
# Shellscript: base.sh  print number to different bases (Bourne Shell)
# Author : Heiner Steven (heiner.steven@odn.de)
# Date : 070395
# Category : Desktop
# $Id: base.sh,v 1.2 2000/02/06 19:55:35 heiner Exp $
# ==> Above line is RCS ID info.
##########################################################################
# Description
#
# Changes
# 210395 stv fixed error occuring with 0xb as input (0.2)
##########################################################################
# ==> Used in this document with the script author's permission.
# ==> Comments added by document author.
NOARGS=65
PN=`basename "$0"` # Program name
VER=`echo '$Revision: 1.2 $'  cut d' ' f2` # ==> VER=1.2
Usage () {
echo "$PN  print number to different bases, $VER (stv '95)
usage: $PN [number ...]
If no number is given, the numbers are read from standard input.
A number may be
binary (base 2) starting with 0b (i.e. 0b1100)
octal (base 8) starting with 0 (i.e. 014)
hexadecimal (base 16) starting with 0x (i.e. 0xc)
decimal otherwise (i.e. 12)" >&2
exit $NOARGS
} # ==> Function to print usage message.
Msg () {
for i # ==> in [list] missing.
do echo "$PN: $i" >&2
done
}
Fatal () { Msg "$@"; exit 66; }
PrintBases () {
# Determine base of the number
for i # ==> in [list] missing...
do # ==> so operates on command line arg(s).
case "$i" in
0b*) ibase=2;; # binary
0x*[af]*[AF]*) ibase=16;; # hexadecimal
0*) ibase=8;; # octal
[19]*) ibase=10;; # decimal
*)
Msg "illegal number $i  ignored"
continue;;
esac
# Remove prefix, convert hex digits to uppercase (bc needs this)
number=`echo "$i"  sed e 's:^0[bBxX]::'  tr '[af]' '[AF]'`
# ==> Uses ":" as sed separator, rather than "/".
# Convert number to decimal
dec=`echo "ibase=$ibase; $number"  bc` # ==> 'bc' is calculator utility.
case "$dec" in
[09]*) ;; # number ok
*) continue;; # error: ignore
esac
# Print all conversions in one line.
# ==> 'here document' feeds command list to 'bc'.
echo `bc <<!
obase=16; "hex="; $dec
obase=10; "dec="; $dec
obase=8; "oct="; $dec
obase=2; "bin="; $dec
!
`  sed e 's: : :g'
done
}
while [ $# gt 0 ]
# ==> Is a "while loop" really necessary here,
# ==>+ since all the cases either break out of the loop
# ==>+ or terminate the script.
# ==> (Thanks, Paulo Marcel Coelho Aragao.)
do
case "$1" in
) shift; break;;
h) Usage;; # ==> Help message.
*) Usage;;
*) break;; # first number
esac # ==> More error checking for illegal input might be useful.
shift
done
if [ $# gt 0 ]
then
PrintBases "$@"
else # read from stdin
while read line
do
PrintBases $line
done
fi
exit 0 An alternate method of invoking bc
involves using a here
document embedded within a command substitution
block. This is especially appropriate when a script
needs to pass a list of options and commands to
bc. variable=`bc << LIMIT_STRING
options
statements
operations
LIMIT_STRING
`
...or...
variable=$(bc << LIMIT_STRING
options
statements
operations
LIMIT_STRING
)
Example 1242. Invoking bc using a "here
document" #!/bin/bash
# Invoking 'bc' using command substitution
# in combination with a 'here document'.
var1=`bc << EOF
18.33 * 19.78
EOF
`
echo $var1 # 362.56
# $( ... ) notation also works.
v1=23.53
v2=17.881
v3=83.501
v4=171.63
var2=$(bc << EOF
scale = 4
a = ( $v1 + $v2 )
b = ( $v3 * $v4 )
a * b + 15.35
EOF
)
echo $var2 # 593487.8452
var3=$(bc l << EOF
scale = 9
s ( 1.7 )
EOF
)
# Returns the sine of 1.7 radians.
# The "l" option calls the 'bc' math library.
echo $var3 # .991664810
# Now, try it in a function...
hyp= # Declare global variable.
hypotenuse () # Calculate hypotenuse of a right triangle.
{
hyp=$(bc l << EOF
scale = 9
sqrt ( $1 * $1 + $2 * $2 )
EOF
)
# Unfortunately, can't return floating point values from a Bash function.
}
hypotenuse 3.68 7.31
echo "hypotenuse = $hyp" # 8.184039344
exit 0 Example 1243. Calculating PI #!/bin/bash
# cannon.sh: Approximating PI by firing cannonballs.
# This is a very simple instance of a "Monte Carlo" simulation:
#+ a mathematical model of a reallife event,
#+ using pseudorandom numbers to emulate random chance.
# Consider a perfectly square plot of land, 10000 units on a side.
# This land has a perfectly circular lake in its center,
#+ with a diameter of 10000 units.
# The plot is actually mostly water, except for land in the four corners.
# (Think of it as a square with an inscribed circle.)
#
# We will fire iron cannonballs from an oldstyle cannon
#+ at the square.
# All the shots impact somewhere on the square,
#+ either in the lake or on the dry corners.
# Since the lake takes up most of the area,
#+ most of the shots will SPLASH! into the water.
# Just a few shots will THUD! into solid ground
#+ in the four corners of the square.
#
# If we take enough random, unaimed shots at the square,
#+ Then the ratio of SPLASHES to total shots will approximate
#+ the value of PI/4.
#
# The reason for this is that the cannon is actually shooting
#+ only at the upper righthand quadrant of the square,
#+ i.e., Quadrant I of the Cartesian coordinate plane.
# (The previous explanation was a simplification.)
#
# Theoretically, the more shots taken, the better the fit.
# However, a shell script, as opposed to a compiled language
#+ with floatingpoint math built in, requires a few compromises.
# This tends to lower the accuracy of the simulation, of course.
DIMENSION=10000 # Length of each side of the plot.
# Also sets ceiling for random integers generated.
MAXSHOTS=1000 # Fire this many shots.
# 10000 or more would be better, but would take too long.
PMULTIPLIER=4.0 # Scaling factor to approximate PI.
get_random ()
{
SEED=$(head 1 /dev/urandom  od N 1  awk '{ print $2 }')
RANDOM=$SEED # From "seedingrandom.sh"
#+ example script.
let "rnum = $RANDOM % $DIMENSION" # Range less than 10000.
echo $rnum
}
distance= # Declare global variable.
hypotenuse () # Calculate hypotenuse of a right triangle.
{ # From "altbc.sh" example.
distance=$(bc l << EOF
scale = 0
sqrt ( $1 * $1 + $2 * $2 )
EOF
)
# Setting "scale" to zero rounds down result to integer value,
#+ a necessary compromise in this script.
# This diminshes the accuracy of the simulation, unfortunately.
}
# main() {
# Initialize variables.
shots=0
splashes=0
thuds=0
Pi=0
while [ "$shots" lt "$MAXSHOTS" ] # Main loop.
do
xCoord=$(get_random) # Get random X and Y coords.
yCoord=$(get_random)
hypotenuse $xCoord $yCoord # Hypotenuse of righttriangle =
#+ distance.
((shots++))
printf "#%4d " $shots
printf "Xc = %4d " $xCoord
printf "Yc = %4d " $yCoord
printf "Distance = %5d " $distance # Distance from
#+ center of lake 
# the "origin" 
#+ coordinate (0,0).
if [ "$distance" le "$DIMENSION" ]
then
echo n "SPLASH! "
((splashes++))
else
echo n "THUD! "
((thuds++))
fi
Pi=$(echo "scale=9; $PMULTIPLIER*$splashes/$shots"  bc)
# Multiply ratio by 4.0.
echo n "PI ~ $Pi"
echo
done
echo
echo "After $shots shots, PI looks like approximately $Pi."
# Tends to run a bit high . . .
# Probably due to roundoff error and imperfect randomness of $RANDOM.
echo
# }
exit 0
# One might well wonder whether a shell script is appropriate for
#+ an application as complex and computationintensive as a simulation.
#
# There are at least two justifications.
# 1) As a proof of concept: to show it can be done.
# 2) To prototype and test the algorithms before rewriting
#+ it in a compiled highlevel language.  dc
The dc (desk
calculator) utility is stackoriented
and uses RPN ("Reverse Polish Notation"). Like
bc, it has much of the power of a
programming language. Most persons avoid dc, since it
requires nonintuitive RPN input. Yet, it has its uses. Example 1244. Converting a decimal number to hexadecimal #!/bin/bash
# hexconvert.sh: Convert a decimal number to hexadecimal.
E_NOARGS=65 # Commandline arg missing.
BASE=16 # Hexadecimal.
if [ z "$1" ]
then
echo "Usage: $0 number"
exit $E_NOARGS
# Need a command line argument.
fi
# Exercise: add argument validity checking.
hexcvt ()
{
if [ z "$1" ]
then
echo 0
return # "Return" 0 if no arg passed to function.
fi
echo ""$1" "$BASE" o p"  dc
# "o" sets radix (numerical base) of output.
# "p" prints the top of stack.
# See 'man dc' for other options.
return
}
hexcvt "$1"
exit 0 Studying the info page for
dc gives some insight into its
intricacies. However, there seems to be a small,
select group of dc wizards who
delight in showing off their mastery of this powerful,
but arcane utility. bash$ echo "16i[q]sa[ln0=aln100%Pln100/snlbx]sbA0D68736142snlbxq"  dc"
Bash
Example 1245. Factoring #!/bin/bash
# factr.sh: Factor a number
MIN=2 # Will not work for number smaller than this.
E_NOARGS=65
E_TOOSMALL=66
if [ z $1 ]
then
echo "Usage: $0 number"
exit $E_NOARGS
fi
if [ "$1" lt "$MIN" ]
then
echo "Number to factor must be $MIN or greater."
exit $E_TOOSMALL
fi
# Exercise: Add type checking (to reject noninteger arg).
echo "Factors of $1:"
# 
echo "$1[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2"  dc
# 
# Above line of code written by Michel Charpentier <charpov@cs.unh.edu>.
# Used with permission (thanks).
exit 0  awk
Yet another way of doing floating point math in
a script is using awk's
builtin math functions in a shell
wrapper. Example 1246. Calculating the hypotenuse of a triangle #!/bin/bash
# hypotenuse.sh: Returns the "hypotenuse" of a right triangle.
# ( square root of sum of squares of the "legs")
ARGS=2 # Script needs sides of triangle passed.
E_BADARGS=65 # Wrong number of arguments.
if [ $# ne "$ARGS" ] # Test number of arguments to script.
then
echo "Usage: `basename $0` side_1 side_2"
exit $E_BADARGS
fi
AWKSCRIPT=' { printf( "%3.7f\n", sqrt($1*$1 + $2*$2) ) } '
# command(s) / parameters passed to awk
# Now, pipe the parameters to awk.
echo n "Hypotenuse of $1 and $2 = "
echo $1 $2  awk "$AWKSCRIPT"
exit 0
/ Linux Reviews / Beginners: Learn Linux / Advanced BashScripting Guide

Meet new people
Adult Dating
