/********************************************************************************************************************************/ /* Created: 15-MAR-2001 23:37:29 by OpenVMS SDL EV1-33 */ /* Source: 15-MAR-2001 23:34:55 _$11$DUA933:[BUILD.SDL]MTH$ROUTINES.SDI;1 */ /********************************************************************************************************************************/ /*** MODULE mth$routines ***/ #ifndef __MTH$ROUTINES_LOADED #define __MTH$ROUTINES_LOADED 1 #pragma nostandard #ifdef __cplusplus extern "C" { #define __unknown_params ... #else #define __unknown_params #endif #if !defined(__VAXC) && !defined(VAXC) #define __struct struct #define __union union #else #define __struct variant_struct #define __union variant_union #endif /**************************************************************************** */ /* * */ /* COPYRIGHT (c) 1988 BY * */ /* DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS. * */ /* ALL RIGHTS RESERVED. * */ /* * */ /* THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED * */ /* ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE * */ /* INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER * */ /* COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY * */ /* OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY * */ /* TRANSFERRED. * */ /* * */ /* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE * */ /* AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT * */ /* CORPORATION. * */ /* * */ /* DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS * */ /* SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. * */ /* * */ /* * */ /**************************************************************************** */ /* MTH$ACOS */ /* */ /* Arc Cosine of Angle Expressed in Radians */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ float mth$acos(__unknown_params); /* MTH$DACOS */ /* */ /* Arc Cosine of Angle Expressed in Radians */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ double mth$dacos(__unknown_params); /* MTH$GACOS */ /* */ /* Arc Cosine of Angle Expressed in Radians */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ double mth$gacos(__unknown_params); /* MTH$ACOSD */ /* */ /* Arc Cosine of Angle Expressed in Degrees */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Degrees */ /* routine returns that */ /* angle (in degrees). */ /* */ float mth$acosd(__unknown_params); /* MTH$DACOSD */ /* */ /* Arc Cosine of Angle Expressed in Degrees */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Degrees */ /* routine returns that */ /* angle (in degrees). */ /* */ double mth$dacosd(__unknown_params); /* MTH$GACOSD */ /* */ /* Arc Cosine of Angle Expressed in Degrees */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in Degrees */ /* routine returns that */ /* angle (in degrees). */ /* */ double mth$gacosd(__unknown_params); /* MTH$ASIN */ /* */ /* Arc Sine in Radians */ /* */ /* Given the sine of an angle, the Arc Sine in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ float mth$asin(__unknown_params); /* MTH$DASIN */ /* */ /* Arc Sine in Radians */ /* */ /* Given the sine of an angle, the Arc Sine in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ double mth$dasin(__unknown_params); /* MTH$GASIN */ /* */ /* Arc Sine in Radians */ /* */ /* Given the sine of an angle, the Arc Sine in Radians */ /* routine returns that angle */ /* (in radians). */ /* */ double mth$gasin(__unknown_params); /* MTH$ASIND */ /* */ /* Arc Sine in Degrees */ /* */ /* Given the sine of an angle, the Arc Sine in Degrees */ /* routine returns that angle */ /* (in degrees). */ /* */ float mth$asind(__unknown_params); /* MTH$DASIND */ /* */ /* Arc Sine in Degrees */ /* */ /* Given the sine of an angle, the Arc Sine in Degrees */ /* routine returns that angle */ /* (in degrees). */ /* */ double mth$dasind(__unknown_params); /* MTH$GASIND */ /* */ /* Arc Sine in Degrees */ /* */ /* Given the sine of an angle, the Arc Sine in Degrees */ /* routine returns that angle */ /* (in degrees). */ /* */ double mth$gasind(__unknown_params); /* MTH$ATAN */ /* */ /* Arc Tangent in Radians */ /* */ /* Given the tangent of an angle, the Arc Tangent in Radians */ /* routine returns that angle (in radians). */ /* */ float mth$atan(__unknown_params); /* MTH$DATAN */ /* */ /* Arc Tangent in Radians */ /* */ /* Given the tangent of an angle, the Arc Tangent in Radians */ /* routine returns that angle (in radians). */ /* */ double mth$datan(__unknown_params); /* MTH$GATAN */ /* */ /* Arc Tangent in Radians */ /* */ /* Given the tangent of an angle, the Arc Tangent in Radians */ /* routine returns that angle (in radians). */ /* */ double mth$gatan(__unknown_params); /* MTH$ATAN2 */ /* */ /* Arc Tangent in Radians with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Radians with Two Arguments */ /* routine returns the angle (in radians) */ /* whose tangent is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ float mth$atan2(__unknown_params); /* MTH$DATAN2 */ /* */ /* Arc Tangent in Radians with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Radians with Two Arguments */ /* routine returns the angle (in radians) */ /* whose tangent is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ double mth$datan2(__unknown_params); /* MTH$GATAN2 */ /* */ /* Arc Tangent in Radians with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Radians with Two Arguments */ /* routine returns the angle (in radians) */ /* whose tangent is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ double mth$gatan2(__unknown_params); /* MTH$ATAND */ /* */ /* Arc Tangent in Degrees */ /* */ /* Given the tangent of an angle, the Arc Tangent in Degrees */ /* routine returns that angle (in degrees). */ /* */ float mth$atand(__unknown_params); /* MTH$DATAND */ /* */ /* Arc Tangent in Degrees */ /* */ /* Given the tangent of an angle, the Arc Tangent in Degrees */ /* routine returns that angle (in degrees). */ /* */ double mth$datand(__unknown_params); /* MTH$GATAND */ /* */ /* Arc Tangent in Degrees */ /* */ /* Given the tangent of an angle, the Arc Tangent in Degrees */ /* routine returns that angle (in degrees). */ /* */ double mth$gatand(__unknown_params); /* MTH$ATANH */ /* */ /* Hyperbolic Arc Tangent */ /* */ /* Given the hyperbolic tangent of an angle, the Hyperbolic Arc Tangent */ /* routine returns */ /* the hyperbolic arc tangent of that angle. */ /* */ float mth$atanh(__unknown_params); /* MTH$DATANH */ /* */ /* Hyperbolic Arc Tangent */ /* */ /* Given the hyperbolic tangent of an angle, the Hyperbolic Arc Tangent */ /* routine returns */ /* the hyperbolic arc tangent of that angle. */ /* */ double mth$datanh(__unknown_params); /* MTH$GATANH */ /* */ /* Hyperbolic Arc Tangent */ /* */ /* Given the hyperbolic tangent of an angle, the Hyperbolic Arc Tangent */ /* routine returns */ /* the hyperbolic arc tangent of that angle. */ /* */ double mth$gatanh(__unknown_params); /* MTH$ATAND2 */ /* */ /* Arc Tangent in Degrees with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Degrees with Two Arguments */ /* routine returns */ /* the angle (in degrees) whose tangent */ /* is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ float mth$atand2(__unknown_params); /* MTH$DATAND2 */ /* */ /* Arc Tangent in Degrees with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Degrees with Two Arguments */ /* routine returns */ /* the angle (in degrees) whose tangent */ /* is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ double mth$datand2(__unknown_params); /* MTH$GATAND2 */ /* */ /* Arc Tangent in Degrees with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Degrees with Two Arguments */ /* routine returns */ /* the angle (in degrees) whose tangent */ /* is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ double mth$gatand2(__unknown_params); /* BLAS1$VISAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$visamax(__unknown_params); /* BLAS1$VIDAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$vidamax(__unknown_params); /* BLAS1$VIGAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$vigamax(__unknown_params); /* BLAS1$VICAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$vicamax(__unknown_params); /* BLAS1$VIZAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$vizamax(__unknown_params); /* BLAS1$VIWAMAX */ /* */ /* Obtain the Index of the First Element of a Vector Having */ /* the Largest Absolute Value */ /* */ /* The Otain the Index of the First Element of a Vector Having the */ /* Largest Absolute Value routines find the index of the */ /* first occurrence of a vector element having the maximum absolute */ /* value. */ /* */ int blas1$viwamax(__unknown_params); /* BLAS1$VSASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ float blas1$vsasum(__unknown_params); /* BLAS1$VDASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ double blas1$vdasum(__unknown_params); /* BLAS1$VGASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ double blas1$vgasum(__unknown_params); /* BLAS1$VSCASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ struct {float blas1$vs$$ret_0_ [2];} blas1$vscasum(__unknown_params); /* BLAS1$VDZASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ struct {double blas1$vd$$ret_1_ [2];} blas1$vdzasum(__unknown_params); /* BLAS1$VGWASUM */ /* */ /* Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* */ /* The Obtain the Sum of the Absolute Values of the Elements of a Vector */ /* routines determine the sum of the absolute values of the elements of */ /* the x-element vector x. */ /* */ struct {double blas1$vg$$ret_2_ [2];} blas1$vgwasum(__unknown_params); /* BLAS1$VSAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vsaxpy(__unknown_params); /* BLAS1$VDAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vdaxpy(__unknown_params); /* BLAS1$VGAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vgaxpy(__unknown_params); /* BLAS1$VCAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vcaxpy(__unknown_params); /* BLAS1$VZAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vzaxpy(__unknown_params); /* BLAS1$VWAXPY */ /* */ /* Multiply a Vector by a Scalar and Add a Vector */ /* */ /* The Multiply a Vector by a Scalar and Add a Vector routines compute */ /* n, where n is a scalar number and n and n are n-element vectors. */ /* */ void blas1$vwaxpy(__unknown_params); /* BLAS1$VSCOPY */ /* */ /* Copy a Vector */ /* */ /* The Copy a Vector routines copy n elements of the */ /* vector x to the vector y. */ /* */ void blas1$vscopy(__unknown_params); /* BLAS1$VDCOPY */ /* */ /* Copy a Vector */ /* */ /* The Copy a Vector routines copy n elements of the */ /* vector x to the vector y. */ /* */ void blas1$vdcopy(__unknown_params); /* BLAS1$VCCOPY */ /* */ /* Copy a Vector */ /* */ /* The Copy a Vector routines copy n elements of the */ /* vector x to the vector y. */ /* */ void blas1$vccopy(__unknown_params); /* BLAS1$VZCOPY */ /* */ /* Copy a Vector */ /* */ /* The Copy a Vector routines copy n elements of the */ /* vector x to the vector y. */ /* */ void blas1$vzcopy(__unknown_params); /* BLAS1$VSDOT */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ float blas1$vsdot(__unknown_params); /* BLAS1$VDDOT */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ double blas1$vddot(__unknown_params); /* BLAS1$VGDOT */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ double blas1$vgdot(__unknown_params); /* BLAS1$VCDOTU */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {float blas1$vc$$ret_3_ [2];} blas1$vcdotu(__unknown_params); /* BLAS1$VCDOTC */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {float blas1$vc$$ret_4_ [2];} blas1$vcdotc(__unknown_params); /* BLAS1$VZDOTU */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {double blas1$vz$$ret_5_ [2];} blas1$vzdotu(__unknown_params); /* BLAS1$VZDOTC */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {double blas1$vz$$ret_6_ [2];} blas1$vzdotc(__unknown_params); /* BLAS1$VWDOTU */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {double blas1$vw$$ret_7_ [2];} blas1$vwdotu(__unknown_params); /* BLAS1$VWDOTC */ /* */ /* Obtain the Inner Product of Two Vectors */ /* */ /* The Obtain the Inner Product of Two Vectors routines */ /* return the dot product of two y-element vectors, */ /* x and y */ /* */ struct {double blas1$vw$$ret_8_ [2];} blas1$vwdotc(__unknown_params); /* BLAS1$VSNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ float blas1$vsnrm2(__unknown_params); /* BLAS1$VDNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ double blas1$vdnrm2(__unknown_params); /* BLAS1$VGNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ double blas1$vgnrm2(__unknown_params); /* BLAS1$VSCNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ struct {float blas1$vs$$ret_9_ [2];} blas1$vscnrm2(__unknown_params); /* BLAS1$VDZNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ struct {double blas1$vd$$ret_10_ [2];} blas1$vdznrm2(__unknown_params); /* BLAS1$VGWNRM2 */ /* */ /* Obtain the Euclidean Norm of a Vector */ /* */ /* The Obtain the Ecudlicean Norm of a Vector routines obtain the */ /* Euclidean norm of an n-element vector x. */ /* */ struct {double blas1$vg$$ret_11_ [2];} blas1$vgwnrm2(__unknown_params); /* BLAS1$VSROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vsrot(__unknown_params); /* BLAS1$VDROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vdrot(__unknown_params); /* BLAS1$VGROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vgrot(__unknown_params); /* BLAS1$VCSROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vcsrot(__unknown_params); /* BLAS1$VZDROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vzdrot(__unknown_params); /* BLAS1$VWGROT */ /* */ /* Apply a Givens Plane Rotation */ /* */ /* The Apply a Givens Plane Rotation routines apply a Givens plane */ /* rotation to a pair of n-element vectors x and y. */ /* */ void blas1$vwgrot(__unknown_params); /* BLAS1$VSROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vsrotg(__unknown_params); /* BLAS1$VDROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vdrotg(__unknown_params); /* BLAS1$VGROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vgrotg(__unknown_params); /* BLAS1$VCROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vcrotg(__unknown_params); /* BLAS1$VZROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vzrotg(__unknown_params); /* BLAS1$VWROTG */ /* */ /* Generate the Elements for a Givens Plane Rotation */ /* */ /* The Generate the Elements for a Givens Plane Rotation */ /* routines construct a Givens plane rotation that eliminates the second */ /* element of a two-element vector. */ /* */ void blas1$vwrotg(__unknown_params); /* BLAS1$VSSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vsscal(__unknown_params); /* BLAS1$VDSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vdscal(__unknown_params); /* BLAS1$VGSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vgscal(__unknown_params); /* BLAS1$VCSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vcscal(__unknown_params); /* BLAS1$VCSSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vcsscal(__unknown_params); /* BLAS1$VZSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vzscal(__unknown_params); /* BLAS1$VWSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vwscal(__unknown_params); /* BLAS1$VZDSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vzdscal(__unknown_params); /* BLAS1$VWGSCAL */ /* */ /* Scale the Elements of a Vector */ /* */ /* The Scale the Elements of a Vector routines compute */ /* a * x where a is a scalar number and x is an n-element vector. */ /* */ void blas1$vwgscal(__unknown_params); /* BLAS1$VSSWAP */ /* */ /* Swap the Elements of Two Vectors */ /* */ /* The Swap the Elements of Two Vectors routines swap n */ /* elements of the vector x with the vector y. */ /* */ void blas1$vsswap(__unknown_params); /* BLAS1$VDSWAP */ /* */ /* Swap the Elements of Two Vectors */ /* */ /* The Swap the Elements of Two Vectors routines swap n */ /* elements of the vector x with the vector y. */ /* */ void blas1$vdswap(__unknown_params); /* BLAS1$VCSWAP */ /* */ /* Swap the Elements of Two Vectors */ /* */ /* The Swap the Elements of Two Vectors routines swap n */ /* elements of the vector x with the vector y. */ /* */ void blas1$vcswap(__unknown_params); /* BLAS1$VZSWAP */ /* */ /* Swap the Elements of Two Vectors */ /* */ /* The Swap the Elements of Two Vectors routines swap n */ /* elements of the vector x with the vector y. */ /* */ void blas1$vzswap(__unknown_params); /* MTH$CABS */ /* */ /* Complex Absolute Value */ /* */ /* The Complex Absolute Value routine */ /* returns the absolute value of a complex number (r,i). */ /* */ float mth$cabs(__unknown_params); /* MTH$CDABS */ /* */ /* Complex Absolute Value */ /* */ /* The Complex Absolute Value routine */ /* returns the absolute value of a complex number (r,i). */ /* */ double mth$cdabs(__unknown_params); /* MTH$CGABS */ /* */ /* Complex Absolute Value */ /* */ /* The Complex Absolute Value routine */ /* returns the absolute value of a complex number (r,i). */ /* */ double mth$cgabs(__unknown_params); /* MTH$CCOS */ /* */ /* Cosine of a Complex Number (F-floating Value) */ /* */ /* The Cosine of a Complex Number (F-floating Value) */ /* routine returns the cosine of a complex number as an */ /* F-floating value. */ /* */ struct {float mth$ccos$$ret_12_ [2];} mth$ccos(__unknown_params); /* MTH$CEXP */ /* */ /* Complex Exponential (F-floating Value) */ /* */ /* The Complex Exponential (F-floating Value) */ /* routine returns the complex exponential of a */ /* complex number as an F-floating value. */ /* */ struct {float mth$cexp$$ret_13_ [2];} mth$cexp(__unknown_params); /* MTH$CLOG */ /* */ /* Complex Natural Logarithm (F-floating Value) */ /* */ /* The Complex Natural Logarithm (F-floating Value) */ /* routine returns the complex natural logarithm of a complex number as */ /* an F-floating value. */ /* */ struct {float mth$clog$$ret_14_ [2];} mth$clog(__unknown_params); /* MTH$CMPLX */ /* */ /* Complex Number Made from F-floating-Point */ /* */ /* The Complex Number Made from F-floating-Point */ /* routine returns a complex number from two floating-point input values. */ /* */ struct {float mth$cmpl$$ret_15_ [2];} mth$cmplx(__unknown_params); /* MTH$DCMPLX */ /* */ /* Complex Number Made from D- or G-floating-Point */ /* */ /* The Complex Number Made from */ /* D- or G-floating-Point */ /* routine returns a complex number from two D- or G-floating input values. */ /* */ void mth$dcmplx(__unknown_params); /* MTH$GCMPLX */ /* */ /* Complex Number Made from D- or G-floating-Point */ /* */ /* The Complex Number Made from */ /* D- or G-floating-Point */ /* routine returns a complex number from two D- or G-floating input values. */ /* */ void mth$gcmplx(__unknown_params); /* MTH$CONJG */ /* */ /* Conjugate of a Complex Number (F-floating Value) */ /* */ /* The Conjugate of a Complex Number (F-floating */ /* Value) */ /* routine returns the complex conjugate (r,-i) of a complex number */ /* (r,i) as an F-floating value. */ /* */ struct {float mth$conj$$ret_16_ [2];} mth$conjg(__unknown_params); /* MTH$DCONJG */ /* */ /* Conjugate of a Complex Number */ /* */ /* The Conjugate of a Complex Number */ /* routine returns the complex conjugate (r,-i) of a complex number (r,i). */ /* */ void mth$dconjg(__unknown_params); /* MTH$GCONJG */ /* */ /* Conjugate of a Complex Number */ /* */ /* The Conjugate of a Complex Number */ /* routine returns the complex conjugate (r,-i) of a complex number (r,i). */ /* */ void mth$gconjg(__unknown_params); /* MTH$COS */ /* */ /* Cosine of Angle Expressed in Radians */ /* */ /* The Cosine of Angle Expressed in Radians */ /* routine returns the cosine of a given angle (in radians). */ /* */ float mth$cos(__unknown_params); /* MTH$DCOS */ /* */ /* Cosine of Angle Expressed in Radians */ /* */ /* The Cosine of Angle Expressed in Radians */ /* routine returns the cosine of a given angle (in radians). */ /* */ double mth$dcos(__unknown_params); /* MTH$GCOS */ /* */ /* Cosine of Angle Expressed in Radians */ /* */ /* The Cosine of Angle Expressed in Radians */ /* routine returns the cosine of a given angle (in radians). */ /* */ double mth$gcos(__unknown_params); /* MTH$COSD */ /* */ /* Cosine of Angle Expressed in Degrees */ /* */ /* The Cosine of Angle Expressed in Degrees */ /* routine returns the cosine of a given angle (in degrees). */ /* */ float mth$cosd(__unknown_params); /* MTH$DCOSD */ /* */ /* Cosine of Angle Expressed in Degrees */ /* */ /* The Cosine of Angle Expressed in Degrees */ /* routine returns the cosine of a given angle (in degrees). */ /* */ double mth$dcosd(__unknown_params); /* MTH$GCOSD */ /* */ /* Cosine of Angle Expressed in Degrees */ /* */ /* The Cosine of Angle Expressed in Degrees */ /* routine returns the cosine of a given angle (in degrees). */ /* */ double mth$gcosd(__unknown_params); /* MTH$COSH */ /* */ /* Hyperbolic Cosine */ /* */ /* The Hyperbolic Cosine */ /* routine returns the hyperbolic cosine of */ /* the input value. */ /* */ float mth$cosh(__unknown_params); /* MTH$DCOSH */ /* */ /* Hyperbolic Cosine */ /* */ /* The Hyperbolic Cosine */ /* routine returns the hyperbolic cosine of */ /* the input value. */ /* */ double mth$dcosh(__unknown_params); /* MTH$GCOSH */ /* */ /* Hyperbolic Cosine */ /* */ /* The Hyperbolic Cosine */ /* routine returns the hyperbolic cosine of */ /* the input value. */ /* */ double mth$gcosh(__unknown_params); /* MTH$CSIN */ /* */ /* Sine of a Complex Number (F-floating Value) */ /* */ /* The Sine of a Complex Number (F-floating */ /* Value) */ /* routine returns the sine of a complex number (r,i) as an */ /* F-floating value. */ /* */ struct {float mth$csin$$ret_17_ [2];} mth$csin(__unknown_params); /* MTH$CSQRT */ /* */ /* Complex Square Root (F-floating Value) */ /* */ /* The Complex Square Root (F-floating Value) routine */ /* returns the complex square root of a complex number (r,i). */ /* */ struct {float mth$csqr$$ret_18_ [2];} mth$csqrt(__unknown_params); /* MTH$CVT_D_G */ /* */ /* Convert One Double-Precision Value */ /* */ /* The Convert One Double-Precision Value routines */ /* convert one double-precision value to the */ /* destination data type and return the result as a function value. */ /* MTH$CVT_D_G converts a D-floating value to G-floating and */ /* MTH$CVT_G_D converts a G-floating value to a D-floating value. */ /* */ double mth$cvt_d_g(__unknown_params); /* MTH$CVT_G_D */ /* */ /* Convert One Double-Precision Value */ /* */ /* The Convert One Double-Precision Value routines */ /* convert one double-precision value to the */ /* destination data type and return the result as a function value. */ /* MTH$CVT_D_G converts a D_floating value to G_floating and */ /* MTH$CVT_G_D converts a G_floating value to a D_floating value. */ /* */ double mth$cvt_g_d(__unknown_params); /* MTH$CVT_DA_GA */ /* */ /* Convert an Array of Double-Precision Values */ /* */ /* The Convert an Array of */ /* Double-Precision Values */ /* routines convert a contiguous array of */ /* double-precision values to the destination data type and return the results */ /* as an array. MTH$CVT_DA_GA converts D-floating values to G-floating and */ /* MTH$CVT_GA_DA converts G-floating values to D-floating. */ /* */ void mth$cvt_da_ga(__unknown_params); /* MTH$CVT_GA_DA */ /* */ /* Convert an Array of Double-Precision Values */ /* */ /* The Convert an Array of */ /* Double-Precision Values */ /* routines convert a contiguous array of */ /* double-precision values to the destination data type and return the results */ /* as an array. MTH$CVT_DA_GA converts D_floating values to G_floating and */ /* MTH$CVT_GA_DA converts G_floating values to D_floating. */ /* */ void mth$cvt_ga_da(__unknown_params); /* MTH$CDCOS */ /* */ /* Cosine of a Complex Number */ /* */ /* The Cosine of a Complex Number */ /* routine returns the cosine of a complex number. */ /* */ void mth$cdcos(__unknown_params); /* MTH$CGCOS */ /* */ /* Cosine of a Complex Number */ /* */ /* The Cosine of a Complex Number */ /* routine returns the cosine of a complex number. */ /* */ void mth$cgcos(__unknown_params); /* MTH$CDEXP */ /* */ /* Complex Exponential */ /* */ /* The Complex Exponential */ /* routine returns the complex exponential of a */ /* complex number. */ /* */ void mth$cdexp(__unknown_params); /* MTH$CGEXP */ /* */ /* Complex Exponential */ /* */ /* The Complex Exponential */ /* routine returns the complex exponential of a */ /* complex number. */ /* */ void mth$cgexp(__unknown_params); /* MTH$CDLOG */ /* */ /* Complex Natural Logarithm */ /* */ /* The Complex Natural Logarithm */ /* routine returns the complex natural logarithm of a complex number. */ /* */ void mth$cdlog(__unknown_params); /* MTH$CGLOG */ /* */ /* Complex Natural Logarithm */ /* */ /* The Complex Natural Logarithm */ /* routine returns the complex natural logarithm of a complex number. */ /* */ void mth$cglog(__unknown_params); /* MTH$CDSIN */ /* */ /* Sine of a Complex Number */ /* */ /* The Sine of a Complex Number */ /* routine returns the sine of a complex number (r,i). */ /* */ void mth$cdsin(__unknown_params); /* MTH$CGSIN */ /* */ /* Sine of Complex Number */ /* */ /* The Sine of Complex Number */ /* routine returns the sine of a complex number (r,i). */ /* */ void mth$cgsin(__unknown_params); /* MTH$CDSQRT */ /* */ /* Complex Square Root */ /* */ /* The Complex Square Root routine */ /* returns the complex square root of a complex number (r,i). */ /* */ void mth$cdsqrt(__unknown_params); /* MTH$CGSQRT */ /* */ /* Complex Square Root */ /* */ /* The Complex Square Root routine */ /* returns the complex square root of a complex number (r,i). */ /* */ void mth$cgsqrt(__unknown_params); /* MTH$EXP */ /* */ /* Exponential */ /* */ /* The Exponential */ /* routine returns the exponential of the input value. */ /* */ float mth$exp(__unknown_params); /* MTH$DEXP */ /* */ /* Exponential */ /* */ /* The Exponential */ /* routine returns the exponential of the input value. */ /* */ double mth$dexp(__unknown_params); /* MTH$GEXP */ /* */ /* Exponential */ /* */ /* The Exponential */ /* routine returns the exponential of the input value. */ /* */ double mth$gexp(__unknown_params); /* MTH$VJFOLRLP_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ int mth$vjfolrlp_ma_v5(__unknown_params); /* MTH$VFFOLRLP_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ float mth$vffolrlp_ma_v5(__unknown_params); /* MTH$VDFOLRLP_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ double mth$vdfolrlp_ma_v5(__unknown_params); /* MTH$VGFOLRLP_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ double mth$vgfolrlp_ma_v5(__unknown_params); /* MTH$VJFOLRLN_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ int mth$vjfolrln_ma_v5(__unknown_params); /* MTH$VFFOLRLN_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ float mth$vffolrln_ma_v5(__unknown_params); /* MTH$VDFOLRLN_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ double mth$vdfolrln_ma_v5(__unknown_params); /* MTH$VGFOLRLN_MA_V5 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes both multiplication and addition */ /* operations. Only the last value computed is stored. */ /* */ double mth$vgfolrln_ma_v5(__unknown_params); /* MTH$VJFOLRLP_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ int mth$vjfolrlp_m_v2(__unknown_params); /* MTH$VFFOLRLP_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ float mth$vffolrlp_m_v2(__unknown_params); /* MTH$VDFOLRLP_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vdfolrlp_m_v2(__unknown_params); /* MTH$VGFOLRLP_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vgfolrlp_m_v2(__unknown_params); /* MTH$VJFOLRLN_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ int mth$vjfolrln_m_v2(__unknown_params); /* MTH$VFFOLRLN_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ float mth$vffolrln_m_v2(__unknown_params); /* MTH$VDFOLRLN_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vdfolrln_m_v2(__unknown_params); /* MTH$VGFOLRLN_M_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vgfolrln_m_v2(__unknown_params); /* MTH$VJFOLRLP_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ int mth$vjfolrlp_a_v2(__unknown_params); /* MTH$VFFOLRLP_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ float mth$vffolrlp_a_v2(__unknown_params); /* MTH$VDFOLRLP_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vdfolrlp_a_v2(__unknown_params); /* MTH$VGFOLRLP_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vgfolrlp_a_v2(__unknown_params); /* MTH$VJFOLRLN_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ int mth$vjfolrln_a_v2(__unknown_params); /* MTH$VFFOLRLN_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ float mth$vffolrln_a_v2(__unknown_params); /* MTH$VDFOLRLN_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vdfolrln_a_v2(__unknown_params); /* MTH$VGFOLRLN_A_V2 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition --- Last Value */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition --- */ /* Last Value routines provide a vectorized algorithm for the linear */ /* recurrence relation that includes either a multiplication or an */ /* addition operation. Only the last value computed is stored. */ /* */ double mth$vgfolrln_a_v2(__unknown_params); /* MTH$VJFOLRP_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vjfolrp_ma_v15(__unknown_params); /* MTH$VFFOLRP_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vffolrp_ma_v15(__unknown_params); /* MTH$VDFOLRP_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vdfolrp_ma_v15(__unknown_params); /* MTH$VGFOLRP_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vgfolrp_ma_v15(__unknown_params); /* MTH$VJFOLRN_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vjfolrn_ma_v15(__unknown_params); /* MTH$VFFOLRN_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vffolrn_ma_v15(__unknown_params); /* MTH$VDFOLRN_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vdfolrn_ma_v15(__unknown_params); /* MTH$VGFOLRN_MA_V15 */ /* */ /* First Order Linear Recurrence --- Multiplication and Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication and Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes both multiplication and addition */ /* operations. */ /* */ void mth$vgfolrn_ma_v15(__unknown_params); /* MTH$VJFOLRP_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vjfolrp_m_v8(__unknown_params); /* MTH$VFFOLRP_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vffolrp_m_v8(__unknown_params); /* MTH$VDFOLRP_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vdfolrp_m_v8(__unknown_params); /* MTH$VGFOLRP_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vgfolrp_m_v8(__unknown_params); /* MTH$VJFOLRN_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vjfolrn_m_v8(__unknown_params); /* MTH$VFFOLRN_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vffolrn_m_v8(__unknown_params); /* MTH$VDFOLRN_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vdfolrn_m_v8(__unknown_params); /* MTH$VGFOLRN_M_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vgfolrn_m_v8(__unknown_params); /* MTH$VJFOLRP_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vjfolrp_a_v8(__unknown_params); /* MTH$VFFOLRP_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vffolrp_a_v8(__unknown_params); /* MTH$VDFOLRP_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vdfolrp_a_v8(__unknown_params); /* MTH$VGFOLRP_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vgfolrp_a_v8(__unknown_params); /* MTH$VJFOLRN_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vjfolrn_a_v8(__unknown_params); /* MTH$VFFOLRN_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vffolrn_a_v8(__unknown_params); /* MTH$VDFOLRN_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vdfolrn_a_v8(__unknown_params); /* MTH$VGFOLRN_A_V8 */ /* */ /* First Order Linear Recurrence --- Multiplication or Addition */ /* */ /* The First Order Linear Recurrence --- Multiplication or Addition */ /* routines provide a vectorized algorithm for the linear recurrence */ /* relation that includes either a multiplication or an addition */ /* operation, but not both. */ /* */ void mth$vgfolrn_a_v8(__unknown_params); /* MTH$HACOS */ /* */ /* Arc Cosine of Angle Expressed in Radians (H-floating Value) */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in */ /* Radians (H-floating Value) routine returns that angle (in radians) in */ /* H-floating-point precision. */ /* */ void mth$hacos(__unknown_params); /* MTH$HACOSD */ /* */ /* Arc Cosine of Angle Expressed in Degrees (H-Floating Value) */ /* */ /* Given the cosine of an angle, the Arc Cosine of Angle Expressed in */ /* Degrees (H-Floating Value) */ /* routine returns that */ /* angle (in degrees) as an H-floating value. */ /* */ void mth$hacosd(__unknown_params); /* MTH$HASIN */ /* */ /* Arc Sine in Radians (H-floating Value) */ /* */ /* Given the sine of an angle, the Arc Sine in Radians (H-floating Value) */ /* routine returns that angle */ /* (in radians) as an H-floating value. */ /* */ void mth$hasin(__unknown_params); /* MTH$HASIND */ /* */ /* Arc Sine in Degrees (H-Floating Value) */ /* */ /* Given the sine of an angle, the Arc Sine in Degrees (H-Floating Value) */ /* routine returns that angle */ /* (in degrees) as an H-floating value. */ /* */ void mth$hasind(__unknown_params); /* MTH$HATAN */ /* */ /* Arc Tangent in Radians (H-floating Value) */ /* */ /* Given the tangent of an angle, the Arc Tangent in Radians (H-floating Value) */ /* routine returns that angle (in radians) */ /* as an H-floating value. */ /* */ void mth$hatan(__unknown_params); /* MTH$HATAN2 */ /* */ /* Arc Tangent in Radians (H-floating Value) with Two Arguments */ /* */ /* Given cosine and cosine, the Arc Tangent in */ /* Radians (H-floating Value) with Two Arguments routine returns the */ /* angle (in radians) as an H-floating value whose tangent is given by */ /* the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ void mth$hatan2(__unknown_params); /* MTH$HATAND */ /* */ /* Arc Tangent in Degrees (H-floating Value) */ /* */ /* Given the tangent of an angle, the Arc Tangent in Degrees (H-floating Value) */ /* routine returns that angle (in degrees) */ /* as an H-floating point value. */ /* */ void mth$hatand(__unknown_params); /* MTH$HATANH */ /* */ /* Hyperbolic Arc Tangent (H-floating Value) */ /* */ /* Given the hyperbolic tangent of an angle, the Hyperbolic Arc */ /* Tangent */ /* line_break */ /* H-floating value */ /* (H-floating Value) routine returns */ /* the hyperbolic arc tangent (as an */ /* line_break */ /* H-floating value of that angle. */ /* line_break */ /* */ void mth$hatanh(__unknown_params); /* MTH$HCOS */ /* */ /* Cosine of Angle Expressed in Radians (H-floating Value) */ /* */ /* The Cosine of Angle Expressed in Radians */ /* (H-floating Value) */ /* routine returns the cosine of a given angle (in radians) as an */ /* H-floating value. */ /* */ void mth$hcos(__unknown_params); /* MTH$HCOSD */ /* */ /* Cosine of Angle Expressed in Degrees (H-floating Value) */ /* */ /* The Cosine of Angle Expressed in Degrees */ /* (H-floating Value) */ /* routine returns the cosine of a given angle (in degrees) as an */ /* H-floating value. */ /* */ void mth$hcosd(__unknown_params); /* MTH$HCOSH */ /* */ /* Hyperbolic Cosine (H-floating Value) */ /* */ /* The Hyperbolic Cosine */ /* routine returns the hyperbolic cosine of */ /* the input value as an H-floating value. */ /* */ void mth$hcosh(__unknown_params); /* MTH$HEXP */ /* */ /* Exponential (H-floating Value) */ /* */ /* The Exponential */ /* routine returns the exponential of the input value as an H-floating */ /* value. */ /* */ void mth$hexp(__unknown_params); /* MTH$HLOG10 */ /* */ /* Common Logarithm (H-floating Value) */ /* */ /* The Common Logarithm (H-floating Value) */ /* routine returns the common (base 10) logarithm of */ /* the input argument as an H-floating value. */ /* */ void mth$hlog10(__unknown_params); /* MTH$HLOG */ /* */ /* Natural Logarithm (H-floating Value) */ /* */ /* The Natural Logarithm (H-floating Value) */ /* routine returns the natural (base e) logarithm of */ /* the input argument as an H-floating value. */ /* */ void mth$hlog(__unknown_params); /* MTH$HLOG2 */ /* */ /* Base 2 Logarithm (H-floating Value) */ /* */ /* The Base 2 Logarithm (H-floating Value) */ /* routine returns the base 2 logarithm of the input value */ /* specified by floating-point-input-value as an H-floating */ /* value. */ /* */ void mth$hlog2(__unknown_params); /* MTH$HSIN */ /* */ /* Sine of Angle Expressed in Radians (H-floating Value) */ /* */ /* The Sine of Angle Expressed in Radians (H-floating */ /* Value) */ /* routine returns the sine of a given angle (in radians) as an */ /* H-floating value. */ /* */ void mth$hsin(__unknown_params); /* MTH$HSIND */ /* */ /* Sine of Angle Expressed in Degrees (H-floating Value) */ /* */ /* The Sine of Angle Expressed in Degrees (H-floating */ /* Value) */ /* routine returns the sine of a given angle (in degrees) as an */ /* H-floating value. */ /* */ void mth$hsind(__unknown_params); /* MTH$HSINH */ /* */ /* Hyperbolic Sine (H-floating Value) */ /* */ /* The Hyperbolic Sine (H-floating Value) */ /* routine returns the hyperbolic sine of the input */ /* value specified by floating-point-input-value as an */ /* H-floating value. */ /* */ void mth$hsinh(__unknown_params); /* MTH$HSQRT */ /* */ /* Square Root (H-floating Value) */ /* */ /* The Square Root (H-floating Value) */ /* routine returns the square root of the input value */ /* floating-point-input-value as an H-floating value. */ /* */ void mth$hsqrt(__unknown_params); /* MTH$HTAN */ /* */ /* Tangent of Angle Expressed in Radians (H-floating Value) */ /* */ /* The Tangent of Angle Expressed in Radians */ /* (H-floating Value) */ /* routine returns the tangent of a given angle (in radians) as an */ /* H-floating value. */ /* */ void mth$htan(__unknown_params); /* MTH$HTAND */ /* */ /* Tangent of Angle Expressed in Degrees (H-floating Value) */ /* */ /* The Tangent of Angle Expressed in Degrees */ /* (H-floating Value) */ /* routine returns the tangent of a given angle (in degrees) as an */ /* H-floating value. */ /* */ void mth$htand(__unknown_params); /* MTH$HTANH */ /* */ /* Compute the Hyperbolic Tangent (H-floating Value) */ /* */ /* The Compute the Hyperbolic Tangent (H-floating */ /* Value) */ /* routine returns the hyperbolic tangent */ /* of the input value as an H-floating value. */ /* */ void mth$htanh(__unknown_params); /* MTH$HATAND2 */ /* */ /* Arc Tangent in Degrees (H-floating Value) with Two Arguments */ /* */ /* Given cosine and cosine, MTH$xHTAND2 returns */ /* the angle (in degrees) whose tangent */ /* is given by the quotient of cosine and cosine, */ /* cosine/cosine. */ /* */ void mth$hatand2(__unknown_params); /* MTH$AIMAG */ /* */ /* Imaginary Part of a Complex Number */ /* */ /* The Imaginary Part of a Complex Number */ /* routine returns the imaginary part of a complex number. */ /* */ float mth$aimag(__unknown_params); /* MTH$DIMAG */ /* */ /* Imaginary Part of a Complex Number */ /* */ /* The Imaginary Part of a Complex Number */ /* routine returns the imaginary part of a complex number. */ /* */ double mth$dimag(__unknown_params); /* MTH$GIMAG */ /* */ /* Imaginary Part of a Complex Number */ /* */ /* The Imaginary Part of a Complex Number */ /* routine returns the imaginary part of a complex number. */ /* */ double mth$gimag(__unknown_params); /* MTH$ALOG */ /* */ /* Natural Logarithm */ /* */ /* The Natural Logarithm routine returns the natural (base e) logarithm of */ /* the input argument. */ /* */ float mth$alog(__unknown_params); /* MTH$DLOG */ /* */ /* Natural Logarithm */ /* */ /* The Natural Logarithm routine returns the natural (base e) logarithm of */ /* the input argument. */ /* */ double mth$dlog(__unknown_params); /* MTH$GLOG */ /* */ /* Natural Logarithm */ /* */ /* The Natural Logarithm routine returns the natural (base e) logarithm of */ /* the input argument. */ /* */ double mth$glog(__unknown_params); /* MTH$ALOG10 */ /* */ /* Common Logarithm */ /* */ /* The Common Logarithm routine returns the common (base 10) logarithm of */ /* the input argument. */ /* */ float mth$alog10(__unknown_params); /* MTH$DLOG10 */ /* */ /* Common Logarithm */ /* */ /* The Common Logarithm routine returns the common (base 10) logarithm of */ /* the input argument. */ /* */ double mth$dlog10(__unknown_params); /* MTH$GLOG10 */ /* */ /* Common Logarithm */ /* */ /* The Common Logarithm routine returns the common (base 10) logarithm of */ /* the input argument. */ /* */ double mth$glog10(__unknown_params); /* MTH$ALOG2 */ /* */ /* Base 2 Logarithm */ /* */ /* The Base 2 Logarithm routine returns the base 2 logarithm of the input value */ /* specified by floating-point-input-value. */ /* */ float mth$alog2(__unknown_params); /* MTH$DLOG2 */ /* */ /* Base 2 Logarithm */ /* */ /* The Base 2 Logarithm routine returns the base 2 logarithm of the input value */ /* specified by floating-point-input-value. */ /* */ double mth$dlog2(__unknown_params); /* MTH$GLOG2 */ /* */ /* Base 2 Logarithm */ /* */ /* The Base 2 Logarithm routine returns the base 2 logarithm of the input value */ /* specified by floating-point-input-value. */ /* */ double mth$glog2(__unknown_params); /* MTH$RANDOM */ /* */ /* Random Number Generator, Uniformly Distributed */ /* */ /* The Random Number Generator, Uniformly Distributed */ /* routine is a general random number generator. */ /* */ float mth$random(__unknown_params); /* MTH$REAL */ /* */ /* Real Part of a Complex Number */ /* */ /* The Real Part of a Complex Number */ /* routine returns the real part of a complex number. */ /* */ float mth$real(__unknown_params); /* MTH$DREAL */ /* */ /* Real Part of a Complex Number */ /* */ /* The Real Part of a Complex Number */ /* routine returns the real part of a complex number. */ /* */ double mth$dreal(__unknown_params); /* MTH$GREAL */ /* */ /* Real Part of a Complex Number */ /* */ /* The Real Part of a Complex Number */ /* routine returns the real part of a complex number. */ /* */ double mth$greal(__unknown_params); /* MTH$SIN */ /* */ /* Sine of Angle Expressed in Radians */ /* */ /* The Sine of Angle Expressed in Radians */ /* routine returns the sine of a given angle (in radians). */ /* */ float mth$sin(__unknown_params); /* MTH$DSIN */ /* */ /* Sine of Angle Expressed in Radians */ /* */ /* The Sine of Angle Expressed in Radians */ /* routine returns the sine of a given angle (in radians). */ /* */ double mth$dsin(__unknown_params); /* MTH$GSIN */ /* */ /* Sine of Angle Expressed in Radians */ /* */ /* The Sine of Angle Expressed in Radians */ /* routine returns the sine of a given angle (in radians). */ /* */ double mth$gsin(__unknown_params); /* MTH$SIND */ /* */ /* Sine of Angle Expressed in Degrees */ /* */ /* The Sine of Angle Expressed in Degrees */ /* routine returns the sine of a given angle (in degrees). */ /* */ float mth$sind(__unknown_params); /* MTH$DSIND */ /* */ /* Sine of Angle Expressed in Degrees */ /* */ /* The Sine of Angle Expressed in Degrees */ /* routine returns the sine of a given angle (in degrees). */ /* */ double mth$dsind(__unknown_params); /* MTH$GSIND */ /* */ /* Sine of Angle Expressed in Degrees */ /* */ /* The Sine of Angle Expressed in Degrees */ /* routine returns the sine of a given angle (in degrees). */ /* */ double mth$gsind(__unknown_params); /* MTH$SINH */ /* */ /* Hyperbolic Sine */ /* */ /* The Hyperbolic Sine */ /* routine returns the hyperbolic sine of the input */ /* value specified by floating-point-input-value. */ /* */ float mth$sinh(__unknown_params); /* MTH$DSINH */ /* */ /* Hyperbolic Sine */ /* */ /* The Hyperbolic Sine */ /* routine returns the hyperbolic sine of the input */ /* value specified by floating-point-input-value. */ /* */ double mth$dsinh(__unknown_params); /* MTH$GSINH */ /* */ /* Hyperbolic Sine */ /* */ /* The Hyperbolic Sine */ /* routine returns the hyperbolic sine of the input */ /* value specified by floating-point-input-value. */ /* */ double mth$gsinh(__unknown_params); /* MTH$SINCOS */ /* */ /* Sine and Cosine of Angle Expressed in Radians */ /* */ /* The Sine and Cosine of Angle Expressed in Radians */ /* routine returns the sine */ /* and cosine of a given angle (in radians). */ /* */ void mth$sincos(__unknown_params); /* MTH$DSINCOS */ /* */ /* Sine and Cosine of Angle Expressed in Radians */ /* */ /* The Sine and Cosine of Angle Expressed in Radians */ /* routine returns the sine */ /* and the cosine of a given angle (in radians). */ /* */ void mth$dsincos(__unknown_params); /* MTH$GSINCOS */ /* */ /* Sine and Cosine of Angle Expressed in Radians */ /* */ /* The Sine and Cosine of Angle Expressed in Radians */ /* routine returns the sine */ /* and the cosine of a given angle (in radians). */ /* */ void mth$gsincos(__unknown_params); /* MTH$HSINCOS */ /* */ /* Sine and Cosine of Angle Expressed in Radians */ /* */ /* The Sine and Cosine of Angle Expressed in Radians */ /* routine returns the sine */ /* and the cosine of a given angle (in radians). */ /* */ void mth$hsincos(__unknown_params); /* MTH$SINCOSD */ /* */ /* Sine and Cosine of Angle Expressed in Degrees */ /* */ /* The Sine and Cosine of Angle Expressed in Degrees */ /* routine returns the sine and cosine of a given angle (in degrees). */ /* */ void mth$sincosd(__unknown_params); /* MTH$DSINCOSD */ /* */ /* Sine and Cosine of Angle Expressed in Degrees */ /* */ /* The Sine and Cosine of Angle Expressed in Degrees */ /* routine returns the sine and cosine of a given angle (in degrees). */ /* */ void mth$dsincosd(__unknown_params); /* MTH$GSINCOSD */ /* */ /* Sine and Cosine of Angle Expressed in Degrees */ /* */ /* The Sine and Cosine of Angle Expressed in Degrees */ /* routine returns the sine and cosine of a given angle (in degrees). */ /* */ void mth$gsincosd(__unknown_params); /* MTH$HSINCOSD */ /* */ /* Sine and Cosine of Angle Expressed in Degrees */ /* */ /* The Sine and Cosine of Angle Expressed in Degrees */ /* routine returns the sine and cosine of a given angle (in degrees). */ /* */ void mth$hsincosd(__unknown_params); /* MTH$SQRT */ /* */ /* Square Root */ /* */ /* The Square Root */ /* routine returns the square root of the input value */ /* floating-point-input-value. */ /* */ float mth$sqrt(__unknown_params); /* MTH$DSQRT */ /* */ /* Square Root */ /* */ /* The Square Root */ /* routine returns the square root of the input value */ /* floating-point-input-value. */ /* */ double mth$dsqrt(__unknown_params); /* MTH$GSQRT */ /* */ /* Square Root */ /* */ /* The Square Root */ /* routine returns the square root of the input value */ /* floating-point-input-value. */ /* */ double mth$gsqrt(__unknown_params); /* MTH$TAN */ /* */ /* Tangent of Angle Expressed in Radians */ /* */ /* The Tangent of Angle Expressed in Radians */ /* routine returns the tangent of a given angle (in radians). */ /* */ float mth$tan(__unknown_params); /* MTH$DTAN */ /* */ /* Tangent of Angle Expressed in Radians */ /* */ /* The Tangent of Angle Expressed in Radians */ /* routine returns the tangent of a given angle (in radians). */ /* */ double mth$dtan(__unknown_params); /* MTH$GTAN */ /* */ /* Tangent of Angle Expressed in Radians */ /* */ /* The Tangent of Angle Expressed in Radians */ /* routine returns the tangent of a given angle (in radians). */ /* */ double mth$gtan(__unknown_params); /* MTH$TAND */ /* */ /* Tangent of Angle Expressed in Degrees */ /* */ /* The Tangent of Angle Expressed in Degrees */ /* routine returns the tangent of a given angle (in degrees). */ /* */ float mth$tand(__unknown_params); /* MTH$DTAND */ /* */ /* Tangent of Angle Expressed in Degrees */ /* */ /* The Tangent of Angle Expressed in Degrees */ /* routine returns the tangent of a given angle (in degrees). */ /* */ double mth$dtand(__unknown_params); /* MTH$GTAND */ /* */ /* Tangent of Angle Expressed in Degrees */ /* */ /* The Tangent of Angle Expressed in Degrees */ /* routine returns the tangent of a given angle (in degrees). */ /* */ double mth$gtand(__unknown_params); /* MTH$TANH */ /* */ /* Compute the Hyperbolic Tangent */ /* */ /* The Compute the Hyperbolic Tangent */ /* routine returns the hyperbolic tangent */ /* of the input value. */ /* */ float mth$tanh(__unknown_params); /* MTH$DTANH */ /* */ /* Compute the Hyperbolic Tangent */ /* */ /* The Compute the Hyperbolic Tangent */ /* routine returns the hyperbolic tangent */ /* of the input value. */ /* */ double mth$dtanh(__unknown_params); /* MTH$GTANH */ /* */ /* Compute the Hyperbolic Tangent */ /* */ /* The Compute the Hyperbolic Tangent */ /* routine returns the hyperbolic tangent */ /* of the input value. */ /* */ double mth$gtanh(__unknown_params); /* MTH$UMAX */ /* */ /* Compute Unsigned Maximum */ /* */ /* The Compute Unsigned Maximum */ /* routine computes the unsigned longword maximum of n unsigned longword */ /* arguments, where n is greater than or equal to 1. */ /* */ unsigned int mth$umax(__unknown_params); /* MTH$UMIN */ /* */ /* Compute Unsigned Minimum */ /* */ /* The Compute Unsigned Minimum */ /* routine computes the unsigned longword minimum of n unsigned longword */ /* arguments, where n is greater than or */ /* equal to 1. */ /* */ unsigned int mth$umin(__unknown_params); /* MTH$ABS */ /* */ /* F_floating Absolute Value Routine */ /* */ float mth$abs(__unknown_params); /* MTH$DABS */ /* */ /* D_floating Absolute Value Routine */ /* */ double mth$dabs(__unknown_params); /* MTH$GABS */ /* */ /* G_floating Absolute Value Routine */ /* */ double mth$gabs(__unknown_params); /* MTH$HABS */ /* */ /* H_floating Absolute Value Routine */ /* */ void mth$habs(__unknown_params); /* MTH$IIABS */ /* */ /* Word Absolute Value Routine */ /* */ short int mth$iiabs(__unknown_params); /* MTH$JIABS */ /* */ /* Longword Absolute Value Routine */ /* */ int mth$jiabs(__unknown_params); /* MTH$IIAND */ /* */ /* Bitwise AND of Two Word Parameters Routine */ /* */ unsigned short int mth$iiand(__unknown_params); /* MTH$JIAND */ /* */ /* Bitwise AND of Two Longword Parameters Routine */ /* */ unsigned int mth$jiand(__unknown_params); /* MTH$DBLE */ /* */ /* Convert F_floating to D_floating (Exact) Routine */ /* */ double mth$dble(__unknown_params); /* MTH$GDBLE */ /* */ /* Convert F_floating to G_floating (Exact) Routine */ /* */ double mth$gdble(__unknown_params); /* MTH$DIM */ /* */ /* Positive Difference of Two F_floating Parameters Routine */ /* */ float mth$dim(__unknown_params); /* MTH$DDIM */ /* */ /* Positive Difference of Two D_floating Parameters Routine */ /* */ double mth$ddim(__unknown_params); /* MTH$GDIM */ /* */ /* Positive Difference of Two D_floating Parameters Routine */ /* */ double mth$gdim(__unknown_params); /* MTH$HDIM */ /* */ /* Positive Difference of Two D_floating Parameters Routine */ /* */ void mth$hdim(__unknown_params); /* MTH$IIDIM */ /* */ /* Positive Difference of Two Word Parameters Routine */ /* */ short int mth$iidim(__unknown_params); /* MTH$JIDIM */ /* */ /* Positive Difference of Two Longword Parameters Routine */ /* */ int mth$jidim(__unknown_params); /* MTH$IIEOR */ /* */ /* Bitwise Exclusive OR of Two Word Parameters Routine */ /* */ unsigned short int mth$iieor(__unknown_params); /* MTH$JIEOR */ /* */ /* Bitwise Exclusive OR of Two Longword Parameters Routine */ /* */ unsigned int mth$jieor(__unknown_params); /* MTH$IIFIX */ /* */ /* Convert F_floating to Word (Truncated) Routine */ /* */ short int mth$iifix(__unknown_params); /* MTH$JIFIX */ /* */ /* Convert F_floating to Longword (Truncated) Routine */ /* */ int mth$jifix(__unknown_params); /* MTH$FLOATI */ /* */ /* Convert Word to F_floating (Exact) Routine */ /* */ float mth$floati(__unknown_params); /* MTH$DFLOTI */ /* */ /* Convert Word to D_floating (Exact) Routine */ /* */ double mth$dfloti(__unknown_params); /* MTH$GFLOTI */ /* */ /* Convert Word to G_floating (Exact) Routine */ /* */ double mth$gfloti(__unknown_params); /* MTH$FLOATJ */ /* */ /* Convert Longword to F_floating (Exact) Routine */ /* */ float mth$floatj(__unknown_params); /* MTH$DFLOTJ */ /* */ /* Convert Longword to D_floating (Exact) Routine */ /* */ double mth$dflotj(__unknown_params); /* MTH$GFLOTJ */ /* */ /* Convert Longword to G_floating (Exact) Routine */ /* */ double mth$gflotj(__unknown_params); /* MTH$FLOOR */ /* */ /* Convert F_floating to Greatest F_floating Integer Routine */ /* */ float mth$floor(__unknown_params); /* MTH$DFLOOR */ /* */ /* Convert D_floating to Greatest D_floating Integer Routine */ /* */ double mth$dfloor(__unknown_params); /* MTH$GFLOOR */ /* */ /* Convert G_floating to Greatest G_floating Integer Routine */ /* */ double mth$gfloor(__unknown_params); /* MTH$HFLOOR */ /* */ /* Convert H_floating to Greatest H_floating Integer Routine */ /* */ void mth$hfloor(__unknown_params); /* MTH$AINT */ /* */ /* Convert F_floating to Truncated F_floating Routine */ /* */ float mth$aint(__unknown_params); /* MTH$DINT */ /* */ /* Convert D_floating to Truncated D_floating Routine */ /* */ double mth$dint(__unknown_params); /* MTH$IIDINT */ /* */ /* Convert D_floating to Word (Truncated) Routine */ /* */ short int mth$iidint(__unknown_params); /* MTH$JIDINT */ /* */ /* Convert D_floating to Longword (Truncated) Routine */ /* */ int mth$jidint(__unknown_params); /* MTH$GINT */ /* */ /* Convert G_floating to G_floating (Truncated) Routine */ /* */ double mth$gint(__unknown_params); /* MTH$IIGINT */ /* */ /* Convert G_floating to Word (Truncated) Routine */ /* */ short int mth$iigint(__unknown_params); /* MTH$JIGINT */ /* */ /* Convert G_floating to Longword (Truncated) Routine */ /* */ int mth$jigint(__unknown_params); /* MTH$HINT */ /* */ /* Convert H_floating to H_floating (Truncated) Routine */ /* */ void mth$hint(__unknown_params); /* MTH$IIHINT */ /* */ /* Convert H_floating to Truncated Word Routine */ /* */ short int mth$iihint(__unknown_params); /* MTH$JIHINT */ /* */ /* Convert H_floating to Truncated Longword Routine */ /* */ int mth$jihint(__unknown_params); /* MTH$IINT */ /* */ /* Convert F_floating to Word (Truncated) Routine */ /* */ short int mth$iint(__unknown_params); /* MTH$JINT */ /* */ /* Convert F_floating to Longword (Truncated) Routine */ /* */ int mth$jint(__unknown_params); /* MTH$IIOR */ /* */ /* Bitwise Inclusive OR of Two Word Parameters Routine */ /* */ unsigned short int mth$iior(__unknown_params); /* MTH$JIOR */ /* */ /* Bitwise Inclusive OR of Two Longword Parameters Routine */ /* */ unsigned int mth$jior(__unknown_params); /* MTH$AIMAX0 */ /* */ /* F_floating Maximum of N WordParameters Routine */ /* */ float mth$aimax0(__unknown_params); /* MTH$AJMAX0 */ /* */ /* F_floating Maximum of N Longword Parameters Routine */ /* */ float mth$ajmax0(__unknown_params); /* MTH$IMAX0 */ /* */ /* Word Maximum of N Word Parameters Routine */ /* */ short int mth$imax0(__unknown_params); /* MTH$JMAX0 */ /* */ /* Longword Maximum of N Longword Parameters Routine */ /* */ int mth$jmax0(__unknown_params); /* MTH$AMAX1 */ /* */ /* F_floating Maximum of N F_floating Parameters Routine */ /* */ float mth$amax1(__unknown_params); /* MTH$DMAX1 */ /* */ /* D_floating Maximum of N D_floating Parameters Routine */ /* */ double mth$dmax1(__unknown_params); /* MTH$GMAX1 */ /* */ /* G_floating Maximum of N G_floating Parameters Routine */ /* */ double mth$gmax1(__unknown_params); /* MTH$HMAX1 */ /* */ /* H_floating Maximum of N H_floating Parameters Routine */ /* */ void mth$hmax1(__unknown_params); /* MTH$IMAX1 */ /* */ /* Word Maximum of N F_floating Parameters Routine */ /* */ short int mth$imax1(__unknown_params); /* MTH$JMAX1 */ /* */ /* Longword Maximum of N F_floating Parameters Routine */ /* */ int mth$jmax1(__unknown_params); /* MTH$AIMIN0 */ /* */ /* F_floating Minimum of N Word Parameters Routine */ /* */ float mth$aimin0(__unknown_params); /* MTH$AJMIN0 */ /* */ /* F_floating Minimum of N Longword Parameters Routine */ /* */ float mth$ajmin0(__unknown_params); /* MTH$IMIN0 */ /* */ /* Word Minimum of N Word Parameters Routine */ /* */ short int mth$imin0(__unknown_params); /* MTH$JMIN0 */ /* */ /* Longword Minimum of N Longword Parameters Routine */ /* */ int mth$jmin0(__unknown_params); /* MTH$AMIN1 */ /* */ /* F_floating Minimum of N F_floating Parameters Routine */ /* */ float mth$amin1(__unknown_params); /* MTH$DMIN1 */ /* */ /* D_floating Minimum of N D_floating Parameters Routine */ /* */ double mth$dmin1(__unknown_params); /* MTH$GMIN1 */ /* */ /* G_floating Minimum of N G_floating Parameters Routine */ /* */ double mth$gmin1(__unknown_params); /* MTH$HMIN1 */ /* */ /* H_floating Minimum of N H_floating Parameters Routine */ /* */ void mth$hmin1(__unknown_params); /* MTH$IMIN1 */ /* */ /* Word Minimum of N F_floating Parameters Routine */ /* */ short int mth$imin1(__unknown_params); /* MTH$JMIN1 */ /* */ /* Longword Minimum of N F_floating Parameters Routine */ /* */ int mth$jmin1(__unknown_params); /* MTH$AMOD */ /* */ /* Remainder of Two F_floating Parameters Routine */ /* */ float mth$amod(__unknown_params); /* MTH$DMOD */ /* */ /* Remainder of Two D_floating Parameters Routine */ /* */ double mth$dmod(__unknown_params); /* MTH$GMOD */ /* */ /* Remainder of Two G_floating Parameters Routine */ /* */ double mth$gmod(__unknown_params); /* MTH$HMOD */ /* */ /* Remainder of Two H_floating Parameters Routine */ /* */ void mth$hmod(__unknown_params); /* MTH$IMOD */ /* */ /* Remainder of Two Word Parameters Routine */ /* */ short int mth$imod(__unknown_params); /* MTH$JMOD */ /* */ /* Remainder of Two Longword Parameters Routine */ /* */ int mth$jmod(__unknown_params); /* MTH$ANINT */ /* */ /* Convert F_floating to Nearest F_floating Integer Routine */ /* */ float mth$anint(__unknown_params); /* MTH$DNINT */ /* */ /* Convert D_floating to Nearest D_floating Integer Routine */ /* */ double mth$dnint(__unknown_params); /* MTH$IIDNNT */ /* */ /* Convert D_floating to Word Integer Routine */ /* */ short int mth$iidnnt(__unknown_params); /* MTH$JIDNNT */ /* */ /* Convert D_floating to Nearest Longword Integer Routine */ /* */ int mth$jidnnt(__unknown_params); /* MTH$GNINT */ /* */ /* Convert G_floating to Nearest G_floating Integer Routine */ /* */ double mth$gnint(__unknown_params); /* MTH$IIGNNT */ /* */ /* Convert T_floating to Nearest G_floating Integer Routine */ /* */ short int mth$iignnt(__unknown_params); /* MTH$JIGNNT */ /* */ /* Convert G_floating to Nearest Longword Integer Routine */ /* */ int mth$jignnt(__unknown_params); /* MTH$HNINT */ /* */ /* Convert H_floating to Nearest H_floating Integer Routine */ /* */ void mth$hnint(__unknown_params); /* MTH$IIHNNT */ /* */ /* Convert H_floating to Nearest Word Integer Routine */ /* */ short int mth$iihnnt(__unknown_params); /* MTH$JIHNNT */ /* */ /* Convert H_floating to Nearest Longword Integer Routine */ /* */ int mth$jihnnt(__unknown_params); /* MTH$ININT */ /* */ /* Convert F_floating to Nearest Word Integer Routine */ /* */ short int mth$inint(__unknown_params); /* MTH$JNINT */ /* */ /* Convert F_floating to Nearest Longword Integer Routine */ /* */ int mth$jnint(__unknown_params); /* MTH$INOT */ /* */ /* Bitwise Complement of Word Parameter Routine */ /* */ unsigned short int mth$inot(__unknown_params); /* MTH$JNOT */ /* */ /* Bitwise Complement of Longword Parameter Routine */ /* */ unsigned int mth$jnot(__unknown_params); /* MTH$DPROD */ /* */ /* D_floating Product of Two F_floating Parameters Routine */ /* */ double mth$dprod(__unknown_params); /* MTH$GPROD */ /* */ /* G_floating Product of Two F_floating Parameters Routine */ /* */ double mth$gprod(__unknown_params); /* MTH$SGN */ /* */ /* F_floating Sign Function */ /* */ int mth$sgn(__unknown_params); /* MTH$IISHFT */ /* */ /* Bitwise Shift of Word Routine */ /* */ unsigned short int mth$iishft(__unknown_params); /* MTH$JISHFT */ /* */ /* Bitwise Shift of Longword Routine */ /* */ unsigned int mth$jishft(__unknown_params); /* MTH$SIGN */ /* */ /* F_floating Transfer of Sign of Y to Sign of X Routine */ /* */ float mth$sign(__unknown_params); /* MTH$DSIGN */ /* */ /* D_floating Transfer of Sign of Y to Sign of X Routine */ /* */ double mth$dsign(__unknown_params); /* MTH$GSIGN */ /* */ /* G_floating Transfer of Sign of X to Sign of X Routine */ /* */ double mth$gsign(__unknown_params); /* MTH$HSIGN */ /* */ /* H_floating Transfer of Sign of Y to Sign of X Routine */ /* */ void mth$hsign(__unknown_params); /* MTH$IISIGN */ /* */ /* Word Transfer of Sign of Y to Sign of X Routine */ /* */ short int mth$iisign(__unknown_params); /* MTH$JISIGN */ /* */ /* Longword Transfer of Sign of Y to Sign of X Routine */ /* */ int mth$jisign(__unknown_params); /* MTH$SNGL */ /* */ /* Convert D_floating to F_floating (Rounded) Routine */ /* */ float mth$sngl(__unknown_params); /* MTH$SNGLG */ /* */ /* Convert G_floating to F_floating (Rounded) Routine */ /* */ float mth$snglg(__unknown_params); #ifdef __cplusplus } #endif #pragma standard #endif /* __MTH$ROUTINES_LOADED */