Mac OSX Build and Run!

OSX上でのプログラミングの初歩について、情報共有ができればと思います。

スポンサーサイト

上記の広告は1ヶ月以上更新のないブログに表示されています。
新しい記事を書く事で広告が消せます。

Floating point data types

各ヘッダーを参照すると使い方が分かります。

------------------------------------------------
/***************************************
* Floating point data types *
****************************************/
 
typedef float float_t;
typedef double double_t;
 
#define HUGE_VAL 1e500
#define HUGE_VALF 1e50f
 
#define INFINITY HUGE_VALF
 
------------------------------------------------
acos
double_t acos (
double_t x
);
 
acosh
double_t acosh (
double_t x
);
 
acoshl
long double acoshl (
long double x
);
 
acosl
long double acosl (
long double x
);
 
annuity
double_t annuity (
double_t rate,
double_t periods
);
 
asin
double_t asin (
double_t x
);
 
asinh
double_t asinh (
double_t x
);
 
asinhl
long double asinhl (
long double x
);
 
asinl
long double asinl (
long double x
);
 
atan
double_t atan (
double_t x
);
 
atan2
double_t atan2 (
double_t y,
double_t x
);
 
atan2l
long double atan2l (
long double y,
long double x
);
 
atanh
double_t atanh (
double_t x
);
 
atanhl
long double atanhl (
long double x
);
 
atanl
long double atanl (
long double x
);
 
ceil
double_t ceil (
double_t x
);
 
ceill
long double ceill (
long double x
);
 
compound
double_t compound (
double_t rate,
double_t periods
);
 
copysign
double_t copysign (
double_t x,
double_t y
);
 
copysignl
long double copysignl (
long double x,
long double y
);
 
cos
double_t cos (
double_t x
);
 
cosh
double_t cosh (
double_t x
);
 
coshl
long double coshl (
long double x
);
 
cosl
long double cosl (
long double x
);
 
dec2f
float dec2f (
const decimal * d
);
 
dec2l
long dec2l (
const decimal * d
);
 
dec2num
double_t dec2num (
const decimal * d
);
 
dec2numl
long double dec2numl (
const decimal * d
);
 
dec2s
short dec2s (
const decimal * d
);
 
dec2str
void dec2str (
const decform * f,
const decimal * d,
char * s
);

dtox80
void dtox80 (
const double * x,
extended80 * x80
);
 
erf
double_t erf (
double_t x
);
 
erfc
double_t erfc (
double_t x
);
 
erfcl
long double erfcl (
long double x
);
 
erfl
long double erfl (
long double x
);
 
exp
double_t exp (
double_t x
);
 
exp2
double_t exp2 (
double_t x
);
 
exp2l
long double exp2l (
long double x
);
 
expl
long double expl (
long double x
);
 
expm1
double_t expm1 (
double_t x
);
 
expm1l
long double expm1l (
long double x
);
 
fabs
double_t fabs (
double_t x
);
 
fabsl
long double fabsl (
long double x
);
 
fdim
double_t fdim (
double_t x,
double_t y
);
 
fdiml
long double fdiml (
long double x,
long double y
);
 
------------------------------------------------
_FE_DFL_ENV
_FE_DFL_ENV ();
Header: fp.h
Header: fenv.h

feclearexcept
void feclearexcept (
excepts
);
 
Header: fenv.h

fegetenv
void fegetenv (
fenv_t *envp
);
 
fegetexcept
void fegetexcept (
fexcept_t *flagp,
excepts
);
 
fegetround
int fegetround ();
 
feholdexcept
int feholdexcept (
fenv_t *envp
);
 
feraiseexcept
void feraiseexcept (
excepts
);
 
Parameter Descriptions
excepts
 
fesetenv
void fesetenv (
const fenv_t *envp
);
 
fesetexcept
void fesetexcept (
const fexcept_t *flagp,
excepts
);
 
fesetround
int fesetround (
round
);
 
fetestexcept
int fetestexcept (
excepts
);
 
feupdateenv
void feupdateenv (
const fenv_t *envp
);
 
------------------------------------------------
floor
double_t floor (
double_t x
);
 
floorl
long double floorl (
long double x
);

fmax
double_t fmax (
double_t x,
double_t y
);
 
fmaxl
long double fmaxl (
long double x,
long double y
);
 
fmin
double_t fmin (
double_t x,
double_t y
);
 
fminl
long double fminl (
long double x,
long double y
);
 
fmod
double_t fmod (
double_t x,
double_t y
);
 
__fpclassifyd
long __fpclassifyd (
double x
);
 
__fpclassifyf
long __fpclassifyf (
float x
);
 
frexp
double_t frexp (
double_t x,
int * exponent
);
 
frexpl
long double frexpl (
long double x,
int * exponent
);
 
gamma
double_t gamma (
double_t x
);
gammal
long double gammal (
long double x
);
 
hypot
double_t hypot (
double_t x,
double_t y
);
 
 
hypotl
long double hypotl (
long double x,
long double y
);
 
__inf
double_t __inf ();
 
Parameter Descriptions
__isfinited
long __isfinited (
double x
);
 
__isfinitef
long __isfinitef (
float x
);
 
__isnand
long __isnand (
double x
);
 
__isnanf
long __isnanf (
float x
);
 
__isnormald
long __isnormald (
double x
);
 
__isnormalf
long __isnormalf (
float x
);
 
ldexp
double_t ldexp (
double_t x,
int n
);
 
ldexpl
long double ldexpl (
long double x,
int n
);
 
ldtox80
void ldtox80 (
const long double * x,
extended80 * x80
);
 
lgamma
double_t lgamma (
double_t x
);
lgammal
long double lgammal (
long double x
);
 
log
double_t log (
double_t x
);
 
log10
double_t log10 (
double_t x
);
 
log10l
long double log10l (
long double x
);
 
log1p
double_t log1p (
double_t x
);
 
log1pl
long double log1pl (
long double x
);
 
log2
double_t log2 (
double_t x
);
 
log2l
long double log2l (
long double x
);
 
logb
double_t logb (
double_t x
);
 
logbl
long double logbl (
long double x
);
 
logl
long double logl (
long double x
);
 
modf
double_t modf (
double_t x,
double_t * iptr
);
modff
float modff (
float x,
float * iptrf
);
 
nan
double nan (
const char * tagp
);
 
nanf
float nanf (
const char * tagp
);
 
nearbyint
double_t nearbyint (
double_t x
);
 
nearbyintl
long double nearbyintl (
long double x
);
 
nextafterd
double nextafterd (
double x,
double y
);
 
nextafterf
float nextafterf (
float x,
float y
);
 
num2dec
void num2dec (
const decform * f,
double_t x,
decimal * d
);
 
num2decl
void num2decl (
const decform * f,
long double x,
decimal * d
);
 
pi
pi ();
 
pow
double_t pow (
double_t x,
double_t y
);
 
powl
long double powl (
long double x,
long double y
);
 
randomx
double_t randomx (
double_t * x
);
 
relation
relop relation (
double_t x,
double_t y
);
 
relationl
relop relationl (
long double x,
long double y
);
 
remainder
double_t remainder (
double_t x,
double_t y
);
 
remainderl
long double remainderl (
long double x,
long double y
);
 
remquo
double_t remquo (
double_t x,
double_t y,
int * quo
);
 
remquol
long double remquol (
long double x,
long double y,
int * quo
);
 
rint
double_t rint (
double_t x
);
 
rintl
long double rintl (
long double x
);
 
rinttol
long rinttol (
double_t x
);
 
rinttoll
long rinttoll (
long double x
);
 
round
double_t round (
double_t x
);
 
roundl
long double roundl (
long double x
);
 
roundtol
long roundtol (
double_t round
);
 
roundtoll
long roundtoll (
long double x
);
 
S32Set
SInt32 S32Set (
SInt64 value
);
 
Header: Math64.h
 
S64Absolute
SInt64 S64Absolute (
SInt64 value
);
 
------------------------------------------------
Parameter Descriptions
value
 
S64Add
SInt64 S64Add (
SInt64 left,
SInt64 right
);
 
S64And
Boolean S64And (
SInt64 left,
SInt64 right
);
 
S64BitwiseAnd
SInt64 S64BitwiseAnd (
SInt64 left,
SInt64 right
);
 
S64BitwiseEor
SInt64 S64BitwiseEor (
SInt64 left,
SInt64 right
);
 
S64BitwiseNot
SInt64 S64BitwiseNot (
SInt64 value
);
 
S64BitwiseOr
SInt64 S64BitwiseOr (
SInt64 left,
SInt64 right
);
 
S64Compare
SInt32 S64Compare (
SInt64 left,
SInt64 right
);
 
S64Div
Under evaluation
SInt64 S64Div (
SInt64 dividend,
SInt64 divisor
);
 
S64Divide
SInt64 S64Divide (
SInt64 dividend,
SInt64 divisor,
SInt64 * remainder
);
 
S64Eor
Boolean S64Eor (
SInt64 left,
SInt64 right
);
 
S64Max
SInt64 S64Max ();
 
S64Min
SInt64 S64Min ();
 
S64Multiply
SInt64 S64Multiply (
SInt64 left,
SInt64 right
);
 
S64Negate
SInt64 S64Negate (
SInt64 value
);
 
S64Not
Boolean S64Not (
SInt64 value
);
 
S64Or
Boolean S64Or (
SInt64 left,
SInt64 right
);
 
S64Set
SInt64 S64Set (
SInt32 value
);
 
S64SetU
SInt64 S64SetU (
UInt32 value
);
 
S64ShiftLeft
SInt64 S64ShiftLeft (
SInt64 value,
UInt32 shift
);
 
S64ShiftRight
SInt64 S64ShiftRight (
SInt64 value,
UInt32 shift
);
 
S64Subtract
SInt64 S64Subtract (
SInt64 left,
SInt64 right
);
 
------------------------------------------------
scalb
double_t scalb (
double_t x,
_scalb_n_type n
);
 
scalbl
long double scalbl (
long double x,
long n
);
 
__signbitd
long __signbitd (
double x
);
 
__signbitf
long __signbitf (
float x
);
 
sin
double_t sin (
double_t x
);
 
sinh
double_t sinh (
double_t x
);
 
sinhl
long double sinhl (
long double x
);
 
sinl
long double sinl (
long double x
);
 
------------------------------------------------
SInt64ToUInt64
UInt64 SInt64ToUInt64 (
SInt64 value
);
 
------------------------------------------------
sqrt
double_t sqrt (
double_t x
);
function result
See page for a description of the double_t data type.
 
sqrtl
long double sqrtl (
long double x
);
 
str2dec
void str2dec (
const char * s,
short * ix,
decimal * d,
short * vp
);
 
tan
double_t tan (
double_t x
);
 
tanh
double_t tanh (
double_t x
);
 
tanhl
long double tanhl (
long double x
);
 
tanl
long double tanl (
long double x
);
 
trunc
_trunc_return_type trunc (
double_t x
);
 
truncl
long double truncl (
long double x
);
 
------------------------------------------------
U32SetU
UInt32 U32SetU (
UInt64 value
);
 
U64Add
UInt64 U64Add (
UInt64 left,
UInt64 right
);
 
U64And
Boolean U64And (
UInt64 left,
UInt64 right
);
 
U64BitwiseAnd
UInt64 U64BitwiseAnd (
UInt64 left,
UInt64 right
);
 
U64BitwiseEor
UInt64 U64BitwiseEor (
UInt64 left,
UInt64 right
);
 
U64BitwiseNot
UInt64 U64BitwiseNot (
UInt64 value
);
 
U64BitwiseOr
UInt64 U64BitwiseOr (
UInt64 left,
UInt64 right
);
 
U64Compare
SInt32 U64Compare (
UInt64 left,
UInt64 right
);
 
U64Div
Under evaluation
UInt64 U64Div (
UInt64 dividend,
UInt64 divisor
);
 
U64Divide
UInt64 U64Divide (
UInt64 dividend,
UInt64 divisor,
UInt64 * remainder
);
 
U64Eor
Boolean U64Eor (
UInt64 left,
UInt64 right
);
 
U64Max
UInt64 U64Max ();
 
U64Multiply
UInt64 U64Multiply (
UInt64 left,
UInt64 right
);
 
U64Not
Boolean U64Not (
UInt64 value
);
 
U64Or
Boolean U64Or (
UInt64 left,
UInt64 right
);
 
U64Set
UInt64 U64Set (
SInt32 value
);
 
U64SetU
UInt64 U64SetU (
UInt32 value
);
 
U64ShiftLeft
UInt64 U64ShiftLeft (
UInt64 value,
UInt32 shift
);
 
U64ShiftRight
UInt64 U64ShiftRight (
UInt64 value,
UInt32 shift
);
 
U64Subtract
UInt64 U64Subtract (
UInt64 left,
UInt64 right
);
 
UInt64ToSInt64
SInt64 UInt64ToSInt64 (
UInt64 value
);
 
------------------------------------------------
WideAdd
wide * WideAdd (
wide * target,
const wide * source
);
 
WideBitShift
wide * WideBitShift (
wide * src,
long shift
);
 
WideCompare
short WideCompare (
const wide * target,
const wide * source
);
 
WideDivide
long WideDivide (
const wide * dividend,
long divisor,
long * remainder
);
 
WideMultiply
wide * WideMultiply (
long multiplicand,
long multiplier,
wide * target
);
 
WideNegate
wide * WideNegate (
wide * target
);
 
WideShift
wide * WideShift (
wide * target,
long shift
);
 
WideSquareRoot
unsigned long WideSquareRoot (
const wide * source
);
 
WideSubtract
wide * WideSubtract (
wide * target,
const wide * source
);
 
WideWideDivide
wide * WideWideDivide (
wide * dividend,
long divisor,
long * remainder
);
 
------------------------------------------------
x80tod
double x80tod (
const extended80 * x80
);
 
x80told
void x80told (
const extended80 * x80,
long double * x
);

スポンサーサイト
上記広告は1ヶ月以上更新のないブログに表示されています。新しい記事を書くことで広告を消せます。