bammi@dsrgsun.ces.cwru.edu (Jwahar R. Bammi) (12/14/88)
#!/bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #!/bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# pmltests/*
# This archive created: Wed Dec 14 04:43:42 1988
# By: Jwahar R. Bammi(Case Western Reserve University)
# Uucp: {decvax,sun,att}!cwjcc!dsrgsun!bammi
# Csnet: bammi@dsrgsun.ces.CWRU.edu
# Arpa: bammi@dsrgsun.ces.CWRU.edu
#
export PATH; PATH=/bin:$PATH
if test ! -d 'pmltests'
then
echo shar: creating directory "'pmltests'"
mkdir 'pmltests'
fi
echo shar: entering directory "'pmltests'"
cd 'pmltests'
echo shar: extracting "'README'" '(677 characters)'
if test -f 'README'
then
echo shar: over-writing existing file "'README'"
fi
sed 's/^X//' << \SHAR_EOF > 'README'
XThis the test directory for PML (Fred Fish's Portable Math Library)
X
XBefore you make the tests
X - You must have GCC V1.31
X - You should have applied all patches to the gcc library
X (the ones that came with this distribution, and the one
X that came with the gcc V1.31 upgrade).
X - You should have compiled the library again
X - You should have made and installed libpml.a in ../src
X
XTo make tests
X GCC-TOS : use Makefile.tos
X GCC-MINIX : use Makefile.minix
XIn both Makefiles adjust CC to suit your environment.
X--
Xusenet: {decvax,sun}!cwjcc!dsrgsun!bammi jwahar r. bammi
Xcsnet: bammi@dsrgsun.ces.CWRU.edu
Xarpa: bammi@dsrgsun.ces.CWRU.edu
XcompuServe: 71515,155
SHAR_EOF
if test 677 -ne "`wc -c 'README'`"
then
echo shar: error transmitting "'README'" '(should have been 677 characters)'
fi
echo shar: extracting "'c2d.dat'" '(401 characters)'
if test -f 'c2d.dat'
then
echo shar: over-writing existing file "'c2d.dat'"
fi
sed 's/^X//' << \SHAR_EOF > 'c2d.dat'
Xcabs 1.000000000000e00 2.000000000000e00 2.23606798052788e00
Xcabs 0.000000000000e00 2.000000000000e00 2.00000000000000e00
Xcabs 1.000000000000e00 0.000000000000e00 1.00000000000000e00
Xcabs -2.000000000000e00 2.000000000000e00 2.82842713594437e00
Xcabs -1.000000000000e00 -2.000000000000e00 2.23606798052788e00
Xcabs 1.000000000000e00 -2.000000000000e00 2.23606798052788e00
SHAR_EOF
if test 401 -ne "`wc -c 'c2d.dat'`"
then
echo shar: error transmitting "'c2d.dat'" '(should have been 401 characters)'
fi
echo shar: extracting "'dd2d.dat'" '(1082 characters)'
if test -f 'dd2d.dat'
then
echo shar: over-writing existing file "'dd2d.dat'"
fi
sed 's/^X//' << \SHAR_EOF > 'dd2d.dat'
Xatan2 -6.000000000000e-01 -5.000000000000e-01 -2.44685437739309e00
Xatan2 0.000000000000e00 -1.000000000000e00 -1.57079632679490e00
Xatan2 6.000000000000e-01 -5.000000000000e-01 -6.94738276196703e-01
Xatan2 1.000000000000e00 0.000000000000e00 0.00000000000000e00
Xatan2 6.000000000000e-01 5.000000000000e-01 6.94738276196703e-01
Xatan2 0.000000000000e00 1.000000000000e00 1.57079632679490e00
Xatan2 -6.000000000000e-01 5.000000000000e-01 2.44685437739309e00
Xatan2 -1.000000000000e00 0.000000000000e00 -3.14159265358979e00
Xmax 6.0 5.0 6.0
Xmax 0.0 0.0 0.0
Xmax 0.1 0.2 0.2
Xmax -0.1 -0.2 -0.1
Xmax -0.1 0.2 0.2
Xmax 0.1 0.2 0.2
Xmax 0.1 -0.2 0.1
Xmax 1e10 1.1e10 1.1e10
Xmax -1e10 -1.1e10 -1e10
Xmax 1e-10 1.1e-10 1.1e-10
Xmin 6.0 5.0 5.0
Xmin 0.0 0.0 0.0
Xmin 0.1 0.2 0.1
Xmin -0.1 -0.2 -0.2
Xmin -0.1 0.2 -0.1
Xmin 0.1 0.2 0.1
Xmin 0.1 -0.2 -0.2
Xmin 1e10 1.1e10 1e10
Xmin -1e10 -1.1e10 -1.1e10
Xmin 1e-10 1.1e-10 1e-10
SHAR_EOF
if test 1082 -ne "`wc -c 'dd2d.dat'`"
then
echo shar: error transmitting "'dd2d.dat'" '(should have been 1082 characters)'
fi
echo shar: extracting "'c2c.dat'" '(5354 characters)'
if test -f 'c2c.dat'
then
echo shar: over-writing existing file "'c2c.dat'"
fi
sed 's/^X//' << \SHAR_EOF > 'c2c.dat'
Xcsin 1.0e00 2.0e00 3.165778547525405883e00 1.959601044654846191e00
Xcsin 0.0e00 2.0e00 0.0e00 3.626860409975051879e00
Xcsin 1.0e00 0.0e00 8.414709866046905517e-01 0.0e00
Xcsin -2.0e00 2.0e00 -3.420954853296279907e00 -1.509306490421295166e00
Xcsin -1.0e00 -2.0e00 -3.165778547525405883e00 -1.959601044654846191e00
Xcsin 1.0e00 -2.0e00 3.165778547525405883e00 -1.959601044654846191e00
Xccos 1.0e00 2.0e00 2.032723009586334228e00 -3.051897794008255004e00
Xccos 0.0e00 2.0e00 3.762195706367492675e00 0.0e00
Xccos 1.0e00 0.0e00 5.403023064136505127e-01 0.0e00
Xccos -2.0e00 2.0e00 -1.565625846385955810e00 3.297894805669784545e00
Xccos -1.0e00 -2.0e00 2.032723009586334228e00 -3.051897794008255004e00
Xccos 1.0e00 -2.0e00 2.032723009586334228e00 3.051897794008255004e00
Xcexp 1.0e00 2.0e00 -1.131204381585121154e00 2.471726655960083007e00
Xcexp 0.0e00 2.0e00 -4.161468371748924255e-01 9.092974215745925903e-01
Xcexp 1.0e00 0.0e00 2.718281835317611694e00 0.0e00
Xcexp -2.0e00 2.0e00 -5.631934991106390953e-02 1.230600243434309959e-01
Xcexp -1.0e00 -2.0e00 -1.530918665230274200e-01 -3.345118276774883270e-01
Xcexp 1.0e00 -2.0e00 -1.131204381585121154e00 -2.471726655960083007e00
Xctanh 1.0e00 2.0e00 1.166736245155334472e00 -2.434581927955150604e-01
Xctanh 0.0e00 2.0e00 0.0e00 -2.185039848089218139e00
Xctanh 1.0e00 0.0e00 7.615941539406776428e-01 0.0e00
Xctanh -2.0e00 2.0e00 -1.023835599422454834e00 -2.839295566082000732e-02
Xctanh -1.0e00 -2.0e00 -1.166736245155334472e00 2.434581927955150604e-01
Xctanh 1.0e00 -2.0e00 1.166736245155334472e00 2.434581927955150604e-01
Xctan 1.0e00 2.0e00 3.381283208727836608e-02 1.014793619513511657e00
Xctan 0.0e00 2.0e00 0.0e00 9.640275761485099792e-01
Xctan 1.0e00 0.0e00 1.557407721877098083e00 0.0e00
Xctan -2.0e00 2.0e00 2.839295566082000732e-02 1.023835599422454834e00
Xctan -1.0e00 -2.0e00 -3.381283208727836608e-02 -1.014793619513511657e00
Xctan 1.0e00 -2.0e00 3.381283208727836608e-02 -1.014793619513511657e00
Xcsqrt 0.0 0.0 0.000000000000000000e00 0.000000000000000000e00
Xcsqrt 1.0 2.0 1.272019654512405395e00 7.861513718962669372e-01
Xcsqrt 0.0 2.0 1.000000000000000000e00 1.000000000000000000e00
Xcsqrt 1.0 0.0 1.000000000000000000e00 0.000000000000000000e00
Xcsqrt -2.0 2.0 6.435942575335502624e-01 1.553773969411849975e00
Xcsqrt -1.0 2.0 7.861513718962669372e-01 1.272019654512405395e00
Xcsqrt 1.0 2.0 1.272019654512405395e00 7.861513718962669372e-01
Xcsinh 1.0e00 2.0e00 -4.890562593936920166e-01 1.403119236230850219e00
Xcsinh 0.0e00 2.0e00 0.0e00 9.092974215745925903e-01
Xcsinh 1.0e00 0.0e00 1.175201192498207092e00 0.0e00
Xcsinh -2.0e00 2.0e00 1.509306475520133972e00 3.420954853296279907e00
Xcsinh -1.0e00 -2.0e00 4.890562593936920166e-01 -1.403119236230850219e00
Xcsinh 1.0e00 -2.0e00 -4.890562593936920166e-01 -1.403119236230850219e00
Xcrcp 1.0e00 2.0e00 1.999999992549419403e-01 -3.999999985098838806e-01
Xcrcp 0.0e00 2.0e00 0.0e00 -5.0e-01
Xcrcp 1.0e00 0.0e00 1.0e00 0.0e00
Xcrcp -2.0e00 2.0e00 -2.5e-01 -2.5e-01
Xcrcp -1.0e00 -2.0e00 -1.999999992549419403e-01 3.999999985098838806e-01
Xcrcp 1.0e00 -2.0e00 1.999999992549419403e-01 3.999999985098838806e-01
Xclog 1.0e00 2.0e00 8.047189563512802124e-01 1.107148721814155578e00
Xclog 0.0e00 2.0e00 6.931471824645996093e-01 1.570796325802803039e00
Xclog 1.0e00 0.0e00 0.0e00 0.0e00
Xclog -2.0e00 2.0e00 1.039720773696899414e00 2.356194496154785156e00
Xclog -1.0e00 -2.0e00 8.047189563512802124e-01 -2.034443944692611694e00
Xclog 1.0e00 -2.0e00 8.047189563512802124e-01 -1.107148721814155578e00
Xccosh 1.0e00 2.0e0 -6.421481221914291381e-01 1.068607419729232788e00
Xccosh 0.0e00 2.0e00 -4.161468371748924255e-01 0.0e00
Xccosh 1.0e00 0.0e00 1.543080642819404602e00 0.0e00
Xccosh -2.0e00 2.0e00 -1.565625831484794616e00 -3.297894805669784545e00
Xccosh -1.0e00 -2.0e00 -6.421481221914291381e-01 1.068607419729232788e00
Xccosh 1.0e00 -2.0e00 -6.421481221914291381e-01 -1.068607419729232788e00
Xcatan 1.0e00 2.0e00 1.338972523808479309e00 4.023594781756401062e-01
Xcatan 0.0e00 2.0e00 1.570796325802803039e00 5.493061468005180358e-01 /* -real part */
Xcatan 1.0e00 0.0e00 7.853981629014015197e-01 0.0e00
Xcatan -2.0e00 2.0e00 -1.311223268508911132e00 2.388778626918792724e-01
Xcatan -1.0e00 -2.0e00 -1.338972523808479309e00 -4.023594819009304046e-01
Xcatan 1.0e00 -2.0e00 1.338972523808479309e00 -4.023594819009304046e-01
Xcasin 1.0 2.0 4.270785786211490631e-01 1.528570890426635742e00
Xcasin 0.0 2.0 0.000000000000000000e00 1.443635478615760803e00
Xcasin 1.0 0.0 1.570796325802803039e00 0.000000000000000000e00
Xcasin -2.0 2.0 -7.542491331696510314e-01 1.734324455261230468e00
Xcasin -1.0 -2.0 -4.270785823464393615e-01 -1.528570920228958129e00
Xcasin 1.0 -2.0 4.270785823464393615e-01 -1.528570920228958129e00
Xcacos 1.0 2.0 1.143717750906944274e00 -1.528570920228958129e00
Xcacos 0.0 2.0 1.570796325802803039e00 -1.443635478615760803e00
Xcacos 1.0 0.0 0.000000000000000000e00 0.000000000000000000e00
Xcacos -2.0 2.0 2.325045466423034668e00 -1.734324529767036438e00
Xcacos -1.0 -2.0 1.997874900698661804e00 1.528570890426635742e00
Xcacos 1.0 -2.0 1.143717750906944274e00 1.528570890426635742e00
SHAR_EOF
if test 5354 -ne "`wc -c 'c2c.dat'`"
then
echo shar: error transmitting "'c2c.dat'" '(should have been 5354 characters)'
fi
echo shar: extracting "'cc2c.dat'" '(3825 characters)'
if test -f 'cc2c.dat'
then
echo shar: over-writing existing file "'cc2c.dat'"
fi
sed 's/^X//' << \SHAR_EOF > 'cc2c.dat'
Xcadd 1.122999995946884155e00 2.340000003576278686e00 3.560000002384185791e00 4.100000023841857910e00 4.683000028133392334e00 6.440000057220458984e00
Xcadd -1.345669999718666076e00 2.234566986560821533e00 3.348675012588500976e00 -4.122219979763031005e00 2.003005027770996093e00 -1.887652993202209472e00
Xcadd 3.857562988996505737e-01 1.000030040740966796e-01 3.333939403295516967e00 4.349979996681213378e00 3.719695717096328735e00 4.449983000755310058e00
Xcadd 1.575757563114166259e00 0.000000000000000000e00 3.378574609756469726e00 0.000000000000000000e00 4.954332172870635986e00 0.000000000000000000e00
Xcadd -1.233999997377395629e00 -2.334455549716949462e00 -3.000000000000000000e00 -4.000000000000000000e00 -4.234000027179718017e00 -6.334455549716949462e00
Xcadd 1.227000000000000000e04 1.300000000000000000e03 0.000000000000000000e00 3.452000021934509277e-02 1.227000000000000000e04 1.300034515380859375e03
Xcdiv 1.122999995946884155e00 2.340000003576278686e00 3.560000002384185791e00 4.100000023841857910e00 4.609979800879955291e-01 1.263787318021059036e-01
Xcdiv -1.345669999718666076e00 2.234566986560821533e00 3.348675012588500976e00 -4.122219979763031005e00 -4.863302707672119140e-01 6.862613558769226074e-02
Xcdiv 3.857562988996505737e-01 1.000030040740966796e-01 3.333939403295516967e00 4.349979996681213378e00 5.729839205741882324e-02 -4.476501746103167533e-02
Xcdiv 1.575757563114166259e00 0.000000000000000000e00 3.378574609756469726e00 0.000000000000000000e00 4.663971476256847381e-01 0.000000000000000000e00
Xcdiv -1.233999997377395629e00 -2.334455549716949462e00 -3.000000000000000000e00 -4.000000000000000000e00 5.215928852558135986e-01 8.269466646015644073e-02
Xcdiv 1.227000000000000000e04 1.300000000000000000e03 0.000000000000000000e00 3.452000021934509277e-02 3.765932763671875000e04 -3.554461171875000000e05
Xcmult 1.122999995946884155e00 2.340000003576278686e00 3.560000002384185791e00 4.100000023841857910e00 -5.596120119094848632e00 1.293470001220703125e01
Xcmult -1.345669999718666076e00 2.234566986560821533e00 3.348675012588500976e00 -4.122219979763031005e00 4.705165147781372070e00 1.302998638153076171e01
Xcmult 3.857562988996505737e-01 1.000030040740966796e-01 3.333939403295516967e00 4.349979996681213378e00 8.510770574212074279e-01 2.011436134576797485e00
Xcmult 1.575757563114166259e00 0.000000000000000000e00 3.378574609756469726e00 0.000000000000000000e00 5.323814511299133300e00 0.000000000000000000e00
Xcmult -1.233999997377395629e00 -2.334455549716949462e00 -3.000000000000000000e00 -4.000000000000000000e00 -5.635822236537933349e00 1.193936669826507568e01
Xcmult 1.227000000000000000e04 1.300000000000000000e03 0.000000000000000000e00 3.452000021934509277e-02 -4.487600040435791015e01 4.235604019165039062e02
Xcsubt 1.122999995946884155e00 2.340000003576278686e00 3.560000002384185791e00 4.100000023841857910e00 -2.437000006437301635e00 -1.760000020265579223e00
Xcsubt -1.345669999718666076e00 2.234566986560821533e00 3.348675012588500976e00 -4.122219979763031005e00 -4.694344997406005859e00 6.356786966323852539e00
Xcsubt 3.857562988996505737e-01 1.000030040740966796e-01 3.333939403295516967e00 4.349979996681213378e00 -2.948183119297027587e00 -4.249976992607116699e00
Xcsubt 1.575757563114166259e00 0.000000000000000000e00 3.378574609756469726e00 0.000000000000000000e00 -1.802817046642303466e00 0.000000000000000000e00
Xcsubt -1.233999997377395629e00 -2.334455549716949462e00 -3.000000000000000000e00 -4.000000000000000000e00 1.766000002622604370e00 1.665544450283050537e00
Xcsubt 1.227000000000000000e04 1.300000000000000000e03 0.000000000000000000e00 3.452000021934509277e-02 1.227000000000000000e04 1.299965484619140625e03
SHAR_EOF
if test 3825 -ne "`wc -c 'cc2c.dat'`"
then
echo shar: error transmitting "'cc2c.dat'" '(should have been 3825 characters)'
fi
echo shar: extracting "'d2d.dat'" '(8975 characters)'
if test -f 'd2d.dat'
then
echo shar: over-writing existing file "'d2d.dat'"
fi
sed 's/^X//' << \SHAR_EOF > 'd2d.dat'
Xdabs 1.2345 1.2345
Xdabs -1.2345 1.2345
Xdabs 1.2345e+20 1.2345e+20
Xdabs -9.987e+25 9.987e+25
Xdabs -7.89e-24 7.89e-24
Xdabs 5.67e-15 5.67e-15
Xexp -40.0 4.248354255291e-18
Xexp -30.0 9.357622968840e-14
Xexp -20.0 2.061153622438e-09
Xexp -10.0 4.539992976248e-05
Xexp -2.0 1.353352832366e-01
Xexp -1.0 0.36787944117144232159552377016146087
Xexp -0.25 0.77880078307140486824517026697832065
Xexp 0.0 1.000000000000e00
Xexp 0.25 1.28402541668774148407342056806243646
Xexp 1.0 2.71828182845904523536028747135266250
Xexp 2.0 7.389056098930e00
Xexp 10.0 2.202646579480e04
Xexp 20.0 4.851651954097e08
Xexp 30.0 1.068647458152e13
Xexp 40.0 2.353852668370e17
Xsqrt 0.0 0.0
Xsqrt 4.999999999999999999e-02 2.236067977499789696e-01
Xsqrt 2.500000000000000000e-01 5.000000000000000000e-01
Xsqrt 5.000000000000000000e-01 7.071067811865475243e-01
Xsqrt 1.000000000000000000e00 1.000000000000000000e00
Xsqrt 2.000000000000000000e00 1.414213562373095048e00
Xsqrt 1.000000000000000000e01 3.162277660168379332e00
Xsqrt 3.000000000000000000e01 5.477225575051661134e00
Xsqrt 7.000000000000000000e01 8.366600265340755481e00
Xsqrt 2.000000000000000000e02 1.414213562373095049e01
Xsqrt 1.999999999999999999e32 1.414213562373095048e16
Xsqrt 0.6366197723675813430755350534900574 0.79788456080286535587989211986876373
Xsqrt 3.1415926535897932384626433832795028 1.77245385090551602729816748334114518
Xlog 4.999999999999999999e-02 -2.995732273553990993e00
Xlog 2.500000000000000000e-01 -1.386294361119890618e00
Xlog 5.000000000000000000e-01 -6.931471805599453094e-01
Xlog 1.000000000000000000e00 0.000000000000000000e00
Xlog 2.0 0.69314718055994530941723212145817657
Xlog 4.0 1.38629436111989061883446424291635313
Xlog 10.0 2.30258509299404568401799145468436421
Xlog 1.000000000000000000e01 2.302585092994045684e00
Xlog 3.000000000000000000e01 3.401197381662155375e00
Xlog 5.000000000000000000e01 3.912023005428146058e00
Xlog 2.000000000000000000e02 5.298317366548036677e00
Xlog 1.999999999999999999e32 7.437587015636940721e01
Xatanh -9.999899999999999999e-01 -6.103033822758835533e00
Xatanh -5.000000000000000000e-01 -5.493061443340548457e-01
Xatanh -2.500000000000000000e-01 -2.554128118829953416e-01
Xatanh 0.000000000000000000e00 0.000000000000000000e00
Xatanh 2.500000000000000000e-01 2.554128118829953415e-01
Xatanh 5.000000000000000000e-01 5.493061443340548457e-01
Xatanh 9.999899999999999999e-01 6.103033822758835533e00
Xsinh -8.000000000000000000e01 -2.770311192196755026e34
Xsinh -1.000000000000000000e01 -1.101323287470339337e04
Xsinh -5.000000000000000000e-01 -5.210953054937473615e-01
Xsinh 0.000000000000000000e00 0.000000000000000000e00
Xsinh 1.500000000000000000e00 2.129279455094817497e00
Xsinh 1.000000000000000000e01 1.101323287470339337e04
Xsinh 8.000000000000000000e01 2.770311192196755026e34
Xcosh -8.000000000000000000e01 2.770311192196755026e34
Xcosh -1.000000000000000000e01 1.101323292010332313e04
Xcosh -5.000000000000000000e-01 1.127625965206380785e00
Xcosh 0.000000000000000000e00 1.000000000000000000e00
Xcosh 1.500000000000000000e00 2.352409615243247325e00
Xcosh 1.000000000000000000e01 1.101323292010332313e04
Xcosh 8.000000000000000000e01 2.770311192196755026e34
Xtanh -8.000000000000000000e01 -1.000000000000000000e00
Xtanh -1.000000000000000000e01 -9.999999958776927635e-01
Xtanh -5.000000000000000000e-01 -4.621171572600097586e-01
Xtanh 0.000000000000000000e00 0.000000000000000000e00
Xtanh 1.500000000000000000e00 9.051482536448664383e-01
Xtanh 1.000000000000000000e01 9.999999958776927635e-01
Xtanh 8.000000000000000000e01 1.000000000000000000e00
Xsin 5.00e-11 5.000000000000000000e-11
Xsin 0.0 0.0
Xsin 0.25 0.24740395925452292959684870484938920
Xsin 0.5 0.47942553860420300027328793521557139
Xsin 0.78539816339744830961556084581987572 0.70710678118654752440084436210484903
Xsin -0.7853981633974483096155608458198757 -0.7071067811865475244008443621048490
Xsin 1.0 0.84147098480789650665250232163029900
Xsin 2.00e00 9.092974268256816953e-01
Xsin 2.50e00 5.984721441039564939e-01
Xsin 3.50e00 -3.507832276896198480e-01
Xsin 4.00e00 -7.568024953079282514e-01
Xsin 5.00e00 -9.589242746631384689e-01
Xsin 6.00e00 -2.794154981989258727e-01
Xsin 7.50e00 9.379999767747388579e-01
Xsin 8.00e00 9.893582466233817778e-01
Xsin 9.00e00 4.121184852417565697e-01
Xsin 9.50e00 -7.515112046180930728e-02
Xsin -5.00e-01 -4.794255386042030000e-01
Xsin -1.00e00 -8.414709848078965066e-01
Xsin -2.00e00 -9.092974268256816953e-01
Xsin -2.50e00 -5.984721441039564939e-01
Xsin -3.50e00 3.507832276896198480e-01
Xsin -4.00e00 7.568024953079282514e-01
Xsin -5.00e00 9.589242746631384689e-01
Xsin -5.50e00 7.055403255703919063e-01
Xsin -6.50e00 -2.151199880878155242e-01
Xsin -7.50e00 -9.379999767747388579e-01
Xsin -8.00e00 -9.893582466233817778e-01
Xsin -9.00e00 -4.121184852417565697e-01
Xsin -9.50e00 7.515112046180930728e-02
Xcos 5.00e-11 9.999999999999999997e-01
Xcos 0.00e00 9.999999999999999997e-01
Xcos 5.00e-01 8.77582561890372716e-01
Xcos 1.00e00 5.403023058681397173e-01
Xcos 2.00e00 -4.161468365471423870e-01
Xcos 2.50e00 -8.011436155469337148e-01
Xcos 3.50e00 -9.364566872907963376e-01
Xcos 4.00e00 -6.536436208636119144e-01
Xcos 5.00e00 2.836621854632262644e-01
Xcos 5.50e00 7.086697742912599999e-01
Xcos 6.50e00 9.765876257280234999e-01
Xcos 7.50e00 3.466353178350258109e-01
Xcos 8.00e00 -1.455000338086135258e-01
Xcos 9.00e00 -9.111302618846769882e-01
Xcos 9.50e00 -9.971721561963784728e-01
Xcos -5.00e-01 8.775825618903727160e-01
Xcos -1.00e00 5.403023058681397173e-01
Xcos -2.00e00 -4.161468365471423870e-01
Xcos -2.50e00 -8.011436155469337148e-01
Xcos -3.50e00 -9.364566872907963376e-01
Xcos -4.00e00 -6.536436208636119144e-01
Xcos -5.00e00 2.836621854632262644e-01
Xcos -6.00e00 9.601702866503660205e-01
Xcos -6.50e00 9.765876257280234999e-01
Xcos -7.50e00 3.466353178350258109e-01
Xcos -8.00e00 -1.455000338086135258e-01
Xcos -9.00e00 -9.111302618846769882e-01
Xcos -9.50e00 -9.971721561963784728e-01
Xtan -2.000000000000000000e00 2.185039863261518991e00
Xtan -1.000000000000000000e00 -1.557407724654902230e00
Xtan -5.000000000000000000e-01 -5.463024898437905132e-01
Xtan 0.000000000000000000e00 0.000000000000000000e00
Xtan 0.39269908169872415480783042290993786 0.41421356237309504880168872420969807
Xtan 0.25 0.25534192122103626650448223649047368
Xtan 0.5 0.54630248984379051325517946578028538
Xtan 0.78539816339744830961556084581987572 1.0
Xtan -0.78539816339744830961556084581987572 -1.0
Xtan 1.0 1.55740772465490223050697480745836017
Xtan 2.000000000000000000e00 -2.185039863261518991e00
Xlog10 1.00e-10 -1.000000000000000000e01
Xlog10 1.00e-05 -5.000000000000000000e00
Xlog10 5.00e-01 -3.010299956639811952e-01
Xlog10 1.00e00 0.000000000000000000e00
Xlog10 1.50e00 1.760912590556812420e-01
Xlog10 2.0 0.30102999566398119521373889472449303
Xlog10 2.71828182845904523536028747135266250 0.43429448190325182765112891891660508
Xlog10 1.00e05 5.000000000000000000e00
Xlog10 1.00e20 2.000000000000000000e01
Xatan 0.000000000000e00 0.000000000000e00
Xatan 4.999999999999e-02 4.995839572194e-02
Xatan 2.500000000000e-01 2.449786631268e-01
Xatan 3.500000000000e-01 3.366748193867e-01
Xatan 7.000000000000e-01 6.107259643892e-01
Xatan 1.000000000000e00 7.85398163397e-01
Xatan 2.000000000000e00 1.10714871779e00
Xatan 1.400000000000e01 1.49948886200e00
Xatan 3.000000000000e01 1.53747533091e00
Xatan 5.000000000000e01 1.55079899282e00
Xatan 7.000000000000e01 1.55651158420e00
Xatan 9.000000000000e01 1.55968567289e00
Xatan 2.000000000000e02 1.56579636846e00
Xasinh -8.000000000000000000e01 -5.075212875445203927e00
Xasinh -1.000000000000000000e01 -2.998222950297969704e00
Xasinh -5.000000000000000000e-01 -4.812118250596034474e-01
Xasinh 0.000000000000000000e00 0.000000000000000000e00
Xasinh 1.500000000000000000e00 1.194763217287109304e00
Xasinh 1.000000000000000000e01 2.998222950297969738e00
Xasinh 8.000000000000000000e01 5.075212875445207223e00
Xasin -1.000000000000000000e00 -1.570796326794896619e00
Xasin -7.000000000000000000e-01 -7.753974966107530636e-01
Xasin -1.999999999999999999e-01 -2.013579207903307914e-01
Xasin 0.000000000000000000e00 0.000000000000000000e00
Xasin 1.999999999999999999e-01 2.013579207903307914e-01
Xasin 7.000000000000000000e-01 7.753974966107530636e-01
Xasin 1.000000000000000000e00 1.570796326794896619e00
Xacosh 1.000000000000000000e00 0.000000000000000000e00
Xacosh 2.000000000000000000e00 1.316957896924816708e00
Xacosh 1.000000000000000000e01 2.993222846126380897e00
Xacosh 2.000000000000000000e02 5.991458297049387423e00
Xacosh 1.000000000000000000e03 7.600902209541988611e00
Xacosh 1.000000000000000000e05 1.220607264550517372e01
Xacosh 1.000000000000000000e18 4.213967885445276762e01
Xacos -1.000000000000000000e00 3.141592653589793238e00
Xacos -7.000000000000000000e-01 2.346193823405649682e00
Xacos -1.999999999999999999e-01 1.772154247585227410e00
Xacos 0.000000000000000000e00 1.570796326794896619e00
Xacos 1.999999999999999999e-01 1.369438406004565827e00
Xacos 7.000000000000000000e-01 7.953988301841435554e-01
Xacos 1.000000000000000000e00 0.000000000000000000e00
SHAR_EOF
if test 8975 -ne "`wc -c 'd2d.dat'`"
then
echo shar: error transmitting "'d2d.dat'" '(should have been 8975 characters)'
fi
echo shar: extracting "'c2d.c'" '(10044 characters)'
if test -f 'c2d.c'
then
echo shar: over-writing existing file "'c2d.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'c2d.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * c2d.c test complex to double math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect a single
X * double precision complex argument and return a double.
X *
X * Most of the test data in the current data file (c2d.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * c2d [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (c2d.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <real(arg)> <imag(arg)> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * The first field, "name", is the name of the function
X * to test. The second field is the real part of the argument.
X * The third field is the imaginary part of the argument.
X * The last field is the expected result.
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X
X#include "pml.h"
X
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
Xextern double cabs (); /* Complex absolute value */
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X double (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "cabs", cabs, 0.0, /* Complex magnitude */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for c2d test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X ENTER ("main");
X DEBUGWHO (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default real part of argument to 0.0
X * Default imaginary part of argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X COMPLEX argument; /* Specified function argument */
X double expected; /* Specified expected result */
X double result; /* Actual result */
X double error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X extern char *strtok ();
X extern double atof ();
X
X ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X argument.real = 0.0;
X argument.imag = 0.0;
X expected = 0.0;
X sscanf (buffer, "%s %le %le %le",
X function, &argument.real, &argument.imag, &expected);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(argument);
X if (vflag) {
X printf ("%s(%le + j %le) = %30.23le.\n",
X function, argument.real, argument.imag, result);
X }
X if (expected != 0.0) {
X error = (result - expected) / expected;
X } else {
X error = result;
X }
X if (error < 0.0) {
X abs_err = -error;
X } else {
X abs_err = error;
X }
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\treal (arg)\t%25.20le\n", argument.real);
X fprintf (stderr, "\timag (arg)\t%25.20le\n", argument.imag);
X fprintf (stderr, "\tresult\t\t%25.20le\n", result);
X fprintf (stderr, "\texpected\t%25.20le\n", expected);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DEBUGPUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DEBUG3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X LEAVE ();
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X LEAVE ();
X}
SHAR_EOF
if test 10044 -ne "`wc -c 'c2d.c'`"
then
echo shar: error transmitting "'c2d.c'" '(should have been 10044 characters)'
fi
echo shar: extracting "'d2d.c'" '(11125 characters)'
if test -f 'd2d.c'
then
echo shar: over-writing existing file "'d2d.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'd2d.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X
X/*
X * FILE
X *
X * d2d.c test double to double math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect a single
X * double precision argument and return a double.
X *
X * Most of the test data in the current data file (d2d.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * d2d [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (d2d.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <argument> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * The first field, "name", is the name of the function
X * to test (sqrt, ln, exp, etc). The second field
X * is the argument to use in calling the specified function.
X * The third field is the expected result.
X *
X * PROGRAMMER
X *
X * Fred Fish
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X#include "pml.h"
X
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
Xextern double dabs ();
Xextern double acos ();
Xextern double acosh ();
Xextern double asin ();
Xextern double asinh ();
Xextern double atan ();
Xextern double atanh ();
Xextern double cos ();
Xextern double cosh ();
Xextern double exp ();
Xextern double log ();
Xextern double log10 ();
Xextern double sin ();
Xextern double sinh ();
Xextern double sqrt ();
Xextern double tan ();
Xextern double tanh ();
X
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X double (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "dabs", dabs, 0.0, /* Absolute value */
X "acos", acos, 0.0, /* Arc cosine (in radians) */
X "acosh", acosh, 0.0, /* Hyperbolic arc cosine (in radians) */
X "asin", asin, 0.0, /* Arc sine (in radians) */
X "asinh", asinh, 0.0, /* Hyperbolic arc sine (in radians) */
X "atan", atan, 0.0, /* Arc tangent (in radians) */
X "atanh", atanh, 0.0, /* Hyperbolic arc tangent (in radians) */
X "cos", cos, 0.0, /* Cosine (argument in radians) */
X "cosh", cosh, 0.0, /* Hyperbolic cosine (argument in radians) */
X "exp", exp, 0.0, /* Exponential */
X "log", log, 0.0, /* Natural logarithm */
X "log10", log10, 0.0, /* Log to base 10 */
X "sin", sin, 0.0, /* Sine (argument in radians) */
X "sinh", sinh, 0.0, /* Hyperbolic sine (argument in radians) */
X "sqrt", sqrt, 0.0, /* Garden variety square root */
X "tan", tan, 0.0, /* Tangent (argument in radians) */
X "tanh", tanh, 0.0, /* Hyperbolic tangent (argument in radians) */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for d2d test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X VOID dotests ();
X
X DBUG_ENTER ("main");
X DBUG_PROCESS (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X DBUG_RETURN (0);
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
XVOID dotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X double argument; /* Specified function argument */
X double expected; /* Specified expected result */
X double result; /* Actual result */
X double error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X extern char *strtok ();
X extern double atof ();
X
X DBUG_ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X argument = 0.0;
X expected = 0.0;
X sscanf (buffer, "%s %le %le", function, &argument, &expected);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(argument);
X if (vflag) {
X printf ("%s(%le) = %30.23le.\n", function, argument, result);
X }
X if (expected != 0.0) {
X error = (result - expected) / expected;
X } else {
X error = result;
X }
X if (error < 0.0) {
X abs_err = -error;
X } else {
X abs_err = error;
X }
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\targument\t%25.20le\n", argument);
X fprintf (stderr, "\tresult\t\t%25.20le\n", result);
X fprintf (stderr, "\texpected\t%25.20le\n", expected);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X DBUG_VOID_RETURN;
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X DBUG_ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DBUG_PUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DBUG_3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X DBUG_VOID_RETURN;
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X DBUG_ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X DBUG_RETURN (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X DBUG_ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X DBUG_VOID_RETURN;
X}
SHAR_EOF
if test 11125 -ne "`wc -c 'd2d.c'`"
then
echo shar: error transmitting "'d2d.c'" '(should have been 11125 characters)'
fi
echo shar: extracting "'dd2d.c'" '(9819 characters)'
if test -f 'dd2d.c'
then
echo shar: over-writing existing file "'dd2d.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'dd2d.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * dd2d.c test dual double to double math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect two
X * double precision arguments and return a double.
X *
X * Most of the test data in the current data file (dd2d.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * dd2d [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (dd2d.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <arg1> <arg2> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * The first field, "name", is the name of the function
X * to test (sqrt, ln, exp, etc). The second and third fields
X * are the arguments to use in calling the specified function.
X * The last field is the expected result.
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X * (602) 966-8871
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X#include "pml.h"
X
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
Xextern double atan2 ();
Xextern double max ();
Xextern double min ();
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X double (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "atan2", atan2, 0.0, /* Arc tangent with two args */
X "max", max, 0.0, /* Maximum value */
X "min", min, 0.0, /* Minimum value */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for dd2d test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X options (argc, argv);
X dotests (argv);
X statistics ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default argument 1 to 0.0
X * Default argument 2 to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X double arg1; /* Specified function argument 1 */
X double arg2; /* Specified function argument 2 */
X double expected; /* Specified expected result */
X double result; /* Actual result */
X double error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X extern char *strtok ();
X extern double atof ();
X
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X arg1 = 0.0;
X arg2 = 0.0;
X expected = 0.0;
X sscanf (buffer, "%s %le %le %le", function, &arg1, &arg2, &expected);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(arg1, arg2);
X if (vflag) {
X printf ("%s(%le,%le) = %30.23le.\n",
X function, arg1, arg2, result);
X }
X if (expected != 0.0) {
X error = (result - expected) / expected;
X } else {
X error = result;
X }
X if (error < 0.0) {
X abs_err = -error;
X } else {
X abs_err = error;
X }
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\targument 1\t%25.20le\n", arg1);
X fprintf (stderr, "\targument 2\t%25.20le\n", arg2);
X fprintf (stderr, "\tresult\t\t%25.20le\n", result);
X fprintf (stderr, "\texpected\t%25.20le\n", expected);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X}
SHAR_EOF
if test 9819 -ne "`wc -c 'dd2d.c'`"
then
echo shar: error transmitting "'dd2d.c'" '(should have been 9819 characters)'
fi
echo shar: extracting "'c2c.c'" '(11504 characters)'
if test -f 'c2c.c'
then
echo shar: over-writing existing file "'c2c.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'c2c.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * c2c.c test complex to complex math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect a single
X * double precision complex argument and return a double
X * precision complex result.
X *
X * Most of the test data in the current data file (c2c.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * c2c [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (c2c.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <argument> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * Both the argument and the expected result are given
X * in the form:
X *
X * <real> <imag>
X *
X * where <real> is the real part and <imag> is the
X * imaginary part, separated by one or more spaces.
X *
X *
X * NOTE
X *
X * This program uses both the csubt and the cdiv routines,
X * which are pml functions!. Thus if either of these screw
X * up, the results will be unpredictable. BEWARE!
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X#include "pml.h"
X
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
X/*
X * External functions which are used internally.
X */
X
Xextern char *strtok ();
Xextern double atof ();
Xextern double cabs ();
Xextern COMPLEX csubt ();
Xextern COMPLEX cdiv ();
X
X/*
X * External functions to be tested.
X */
X
Xextern COMPLEX cacos();
Xextern COMPLEX casin();
Xextern COMPLEX catan();
Xextern COMPLEX ccos();
Xextern COMPLEX ccosh();
Xextern COMPLEX cexp();
Xextern COMPLEX clog();
Xextern COMPLEX crcp();
Xextern COMPLEX csin();
Xextern COMPLEX csinh();
Xextern COMPLEX csqrt();
Xextern COMPLEX ctan();
Xextern COMPLEX ctanh();
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X COMPLEX (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "cacos", cacos, 0.0, /* Complex arc cosine */
X "casin", casin, 0.0, /* Complex arc sine */
X "catan", catan, 0.0, /* Complex arc tangent */
X "ccos", ccos, 0.0, /* Complex cosine */
X "ccosh", ccosh, 0.0, /* Complex hyperbolic cosine */
X "cexp", cexp, 0.0, /* Complex exponential */
X "clog", clog, 0.0, /* Complex natural logarithm */
X "crcp", crcp, 0.0, /* Complex reciprocal */
X "csin", csin, 0.0, /* Complex sine */
X "csinh", csinh, 0.0, /* Complex hyperbolic sine */
X "csqrt", csqrt, 0.0, /* Complex square root */
X "ctan", ctan, 0.0, /* Complex tangent */
X "ctanh", ctanh, 0.0, /* Complex hyperbolic tangent */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for c2c test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X ENTER ("main");
X DEBUGWHO (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default real part of argument to 0.0
X * Default imaginary part of argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X COMPLEX argument; /* Specified function argument */
X COMPLEX expected; /* Specified expected result */
X COMPLEX result; /* Actual result */
X COMPLEX error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X
X ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X argument.real = argument.imag = 0.0;
X expected.real = expected.imag = 0.0;
X sscanf (buffer, "%s %le %le %le %le", function,
X &argument.real, &argument.imag, &expected.real, &expected.imag);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(argument);
X if (vflag) {
X printf ("%s(%le + j %le) \n = %30.23le + j %30.23le.\n",
X function, argument.real, argument.imag, result.real,
X result.imag);
X }
X if (expected.real != 0.0 || expected.imag != 0.0) {
X error = csubt (result, expected);
X error = cdiv (error, expected);
X } else {
X error = result;
X }
X abs_err = cabs (error);
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\treal (arg)\t\t%25.20le\n", argument.real);
X fprintf (stderr, "\timag (arg)\t\t%25.20le\n", argument.imag);
X fprintf (stderr, "\treal (result)\t\t%25.20le\n",result.real);
X fprintf (stderr, "\timag (result)\t\t%25.20le\n",result.imag);
X fprintf (stderr, "\treal (expected)\t\t%25.20le\n",expected.real);
X fprintf (stderr, "\timag (expected)\t\t%25.20le\n",expected.imag);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DEBUGPUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DEBUG3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X LEAVE ();
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X LEAVE ();
X}
SHAR_EOF
if test 11504 -ne "`wc -c 'c2c.c'`"
then
echo shar: error transmitting "'c2c.c'" '(should have been 11504 characters)'
fi
echo shar: extracting "'cc2c.c'" '(11091 characters)'
if test -f 'cc2c.c'
then
echo shar: over-writing existing file "'cc2c.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'cc2c.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * cc2c.c test complex to complex math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect two
X * double precision complex arguments and return a double
X * precision complex result.
X *
X * Most of the test data in the current data file (cc2c.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * cc2c [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (cc2c.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <arg1> <arg2> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * Both the argument and the expected result are given
X * in the form:
X *
X * <real> <imag>
X *
X * where <real> is the real part and <imag> is the
X * imaginary part, separated by one or more spaces.
X *
X *
X * NOTE
X *
X * This program uses both the csubt and the cdiv routines,
X * which are pml functions!. Thus if either of these screw
X * up, the results will be unpredictable. BEWARE!
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X#include "pml.h"
X
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
X/*
X * External functions which are used internally.
X */
X
Xextern char *strtok ();
Xextern double atof ();
Xextern double cabs ();
Xextern COMPLEX csubt ();
Xextern COMPLEX cdiv ();
X
X/*
X * External functions to be tested.
X */
X
Xextern COMPLEX cadd();
Xextern COMPLEX csubt();
Xextern COMPLEX cdiv();
Xextern COMPLEX cmult();
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X COMPLEX (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "cadd", cadd, 0.0, /* Complex addition */
X "csubt", csubt, 0.0, /* Complex subtraction */
X "cdiv", cdiv, 0.0, /* Complex division */
X "cmult", cmult, 0.0, /* Complex multiplication */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for cc2c test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X ENTER ("main");
X DEBUGWHO (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default real part of argument to 0.0
X * Default imaginary part of argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X COMPLEX arg1; /* Specified function argument 1 */
X COMPLEX arg2; /* Specified function argument 2 */
X COMPLEX expected; /* Specified expected result */
X COMPLEX result; /* Actual result */
X COMPLEX error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X
X ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X arg1.real = arg1.imag = 0.0;
X arg2.real = arg2.imag = 0.0;
X expected.real = expected.imag = 0.0;
X sscanf (buffer, "%s %le %le %le %le %le %le", function,
X &arg1.real, &arg1.imag, &arg2.real, &arg2.imag,
X &expected.real, &expected.imag);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(arg1, arg2);
X if (vflag) {
X printf ("%s(%le + j %le, %le + j %le)\n",
X function, arg1.real, arg1.imag, arg2.real, arg2.imag);
X printf (" = %30.23le + j %30.23le.\n", result.real,
X result.imag);
X }
X if (expected.real != 0.0 || expected.imag != 0.0) {
X error = csubt (result, expected);
X error = cdiv (error, expected);
X } else {
X error = result;
X }
X abs_err = cabs (error);
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\treal (arg1)\t\t%25.20le\n", arg1.real);
X fprintf (stderr, "\timag (arg1)\t\t%25.20le\n", arg1.imag);
X fprintf (stderr, "\treal (arg2)\t\t%25.20le\n", arg2.real);
X fprintf (stderr, "\timag (arg2)\t\t%25.20le\n", arg2.imag);
X fprintf (stderr, "\treal (result)\t\t%25.20le\n",result.real);
X fprintf (stderr, "\timag (result)\t\t%25.20le\n",result.imag);
X fprintf (stderr, "\treal (expected)\t\t%25.20le\n",expected.real);
X fprintf (stderr, "\timag (expected)\t\t%25.20le\n",expected.imag);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DEBUGPUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DEBUG3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X LEAVE ();
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X LEAVE ();
X}
SHAR_EOF
if test 11091 -ne "`wc -c 'cc2c.c'`"
then
echo shar: error transmitting "'cc2c.c'" '(should have been 11091 characters)'
fi
echo shar: extracting "'Makefile.sun'" '(432 characters)'
if test -f 'Makefile.sun'
then
echo shar: over-writing existing file "'Makefile.sun'"
fi
sed 's/^X//' << \SHAR_EOF > 'Makefile.sun'
XCC = cc
XCFLAGS = -DNO_DBUG -O -I../pmlsrc
XLIBS = ../pmlsrc/libpml.a -v
X
Xall : d2d dd2d c2d c2c cc2c
X
Xd2d : d2d.o
X $(CC) -o d2d d2d.o $(LIBS)
X
Xdd2d : dd2d.o
X $(CC) -o dd2d dd2d.o $(LIBS)
X
Xc2d : c2d.o
X $(CC) -o c2d c2d.o $(LIBS)
X
Xc2c : c2c.o
X $(CC) -o c2c c2c.o $(LIBS)
X
Xcc2c : cc2c.o
X $(CC) -o cc2c cc2c.o $(LIBS)
X
X
X#
X# Clean up the directory.
X#
X
Xclean:
X rm -f c2c c2d cc2c d2d dd2d *.BAK *.bak *.tmp nohup.out *.o
SHAR_EOF
if test 432 -ne "`wc -c 'Makefile.sun'`"
then
echo shar: error transmitting "'Makefile.sun'" '(should have been 432 characters)'
fi
echo shar: extracting "'Makefile.minix'" '(423 characters)'
if test -f 'Makefile.minix'
then
echo shar: over-writing existing file "'Makefile.minix'"
fi
sed 's/^X//' << \SHAR_EOF > 'Makefile.minix'
XCC = mgcc
XCFLAGS = -DNO_DBUG -O -I../pmlsrc
XLIBS = -lpml32 -v
X
Xall : d2d dd2d c2d c2c cc2c
X
Xd2d : d2d.o
X $(CC) -o d2d d2d.o $(LIBS)
X
Xdd2d : dd2d.o
X $(CC) -o dd2d dd2d.o $(LIBS)
X
Xc2d : c2d.o
X $(CC) -o c2d c2d.o $(LIBS)
X
Xc2c : c2c.o
X $(CC) -o c2c c2c.o $(LIBS)
X
Xcc2c : cc2c.o
X $(CC) -o cc2c cc2c.o $(LIBS)
X
X
X#
X# Clean up the directory.
X#
X
Xclean:
X rm -f c2c c2d cc2c d2d dd2d *.BAK *.bak *.tmp nohup.out *.o
SHAR_EOF
if test 423 -ne "`wc -c 'Makefile.minix'`"
then
echo shar: error transmitting "'Makefile.minix'" '(should have been 423 characters)'
fi
echo shar: extracting "'Makefile.tos'" '(494 characters)'
if test -f 'Makefile.tos'
then
echo shar: over-writing existing file "'Makefile.tos'"
fi
sed 's/^X//' << \SHAR_EOF > 'Makefile.tos'
XCC = cgcc
XCFLAGS = -DNO_DBUG -O -I../pmlsrc
XLIBS = /dsrg/bammi/cross-gcc/lib/libpml.a -v
X
Xall : d2d.ttp dd2d.ttp c2d.ttp c2c.ttp cc2c.ttp
X
Xd2d.ttp : d2d.o
X $(CC) -o d2d.ttp d2d.o $(LIBS)
X
Xdd2d.ttp : dd2d.o
X $(CC) -o dd2d.ttp dd2d.o $(LIBS)
X
Xc2d.ttp : c2d.o
X $(CC) -o c2d.ttp c2d.o $(LIBS)
X
Xc2c.ttp : c2c.o
X $(CC) -o c2c.ttp c2c.o $(LIBS)
X
Xcc2c.ttp : cc2c.o
X $(CC) -o cc2c.ttp cc2c.o $(LIBS)
X
X
X#
X# Clean up the directory.
X#
X
Xclean:
X rm -f *.ttp *.BAK *.bak *.tmp nohup.out *.o
SHAR_EOF
if test 494 -ne "`wc -c 'Makefile.tos'`"
then
echo shar: error transmitting "'Makefile.tos'" '(should have been 494 characters)'
fi
echo shar: done with directory "'pmltests'"
cd ..
# End of shell archive
exit 0
usenet: {decvax,sun}!cwjcc!dsrgsun!bammi jwahar r. bammi
csnet: bammi@dsrgsun.ces.CWRU.edu
arpa: bammi@dsrgsun.ces.CWRU.edu
compuServe: 71515,155