Home - sourcemod-central - file revision - plugins/include/float.inc@9d1983bf06c7 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
plugins/include/float.inc
author David Anderson <dvander@alliedmods.net>
Tue Aug 14 01:00:42 2007 +0000 (2007-08-14)
changeset 1324 9d1983bf06c7
parent 1268 9360f5ea2289
child 1330 ab94316bb52b
permissions -rw-r--r--
added SQL_CheckConfig() so sql admin plugins can default back 
     1 /**
     2  * vim: set ts=4 :
     3  * ===============================================================
     4  * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.
     5  * ===============================================================
     6  *
     7  *  This file is part of the SourceMod/SourcePawn SDK.  This file may only be used 
     8  * or modified under the Terms and Conditions of its License Agreement, which is found 
     9  * in LICENSE.txt.  The Terms and Conditions for making SourceMod extensions/plugins 
    10  * may change at any time.  To view the latest information, see:
    11  *   http://www.sourcemod.net/license.php
    12  *
    13  * Version: $Id$
    14  */
    15  
    16 #if defined _float_included
    17  #endinput
    18 #endif
    19 #define _float_included
    20 
    21 /**
    22  * Converts an integer into a floating point value.
    23  *
    24  * @param value			Integer to convert.
    25  * @return				Floating point value.
    26  */
    27 native Float:float(value);
    28 
    29 /**
    30  * Multiplies two floats together.
    31  *
    32  * @param oper1			First value.
    33  * @param oper2			Second value.
    34  * @return				oper1*oper2.
    35  */
    36 native Float:FloatMul(Float:oper1, Float:oper2);
    37 
    38 /**
    39  * Divides the dividend by the divisor.
    40  *
    41  * @param dividend		First value.
    42  * @param divisor		Second value.
    43  * @return				dividend/divisor.
    44  */
    45 native Float:FloatDiv(Float:dividend, Float:divisor);
    46 
    47 /**
    48  * Adds two floats together.
    49  *
    50  * @param oper1			First value.
    51  * @param oper2			Second value.
    52  * @return				oper1+oper2.
    53  */
    54 native Float:FloatAdd(Float:oper1, Float:oper2);
    55 
    56 /**
    57  * Subtracts oper2 from oper1.
    58  *
    59  * @param oper1			First value.
    60  * @param oper2			Second value.
    61  * @return				oper1-oper2.
    62  */
    63 native Float:FloatSub(Float:oper1, Float:oper2);
    64 
    65 /**
    66  * Returns the decimal part of a float.
    67  *
    68  * @param value			Input value.
    69  * @return				Decimal part.
    70  */
    71 native Float:FloatFraction(Float:value);
    72 
    73 /**
    74  * Rounds a float to the closest integer to zero.
    75  *
    76  * @param value			Input value to be rounded.
    77  * @return				Rounded value.
    78  */
    79 native RoundToZero(Float:value);
    80 
    81 /**
    82  * Rounds a float to the next highest integer value.
    83  *
    84  * @param value			Input value to be rounded.
    85  * @return				Rounded value.
    86  */
    87 native RoundToCeil(Float:value);
    88 
    89 /**
    90  * Rounds a float to the next lowest integer value.
    91  *
    92  * @param value			Input value to be rounded.
    93  * @return				Rounded value.
    94  */
    95 native RoundToFloor(Float:value);
    96 
    97 /**
    98  * Standard IEEE rounding.
    99  *
   100  * @param value			Input value to be rounded.
   101  * @return				Rounded value.
   102  */
   103 native RoundToNearest(Float:value);
   104 
   105 /**
   106  * Compares two floats.
   107  *
   108  * @param fOne			First value.
   109  * @param fTwo			Second value.
   110  * @return				Returns 1 if the first argument is greater than the second argument.
   111  *                      Returns -1 if the first argument is smaller than the second argument.
   112  *                      Returns 0 if both arguments are equal.
   113  */
   114 native FloatCompare(Float:fOne, Float:fTwo);
   115 
   116 /**
   117  * Returns the square root of the input value, equivalent to floatpower(value, 0.5).
   118  *
   119  * @param value			Input value.
   120  * @return				Square root of the value.
   121  */
   122 native Float:SquareRoot(Float:value);
   123 
   124 /**
   125  * Returns the value raised to the power of the exponent.
   126  *
   127  * @param value			Value to be raised.
   128  * @param exponent		Value to raise the base.
   129  * @return				value^exponent.
   130  */
   131 native Float:Pow(Float:value, Float:exponent);
   132 
   133 /**
   134  * Returns the value of raising the input by e.
   135  *
   136  * @param value			Input value.
   137  * @return				exp(value).
   138  */
   139 native Float:Exponential(Float:value);
   140 
   141 /**
   142  * Returns the logarithm of any base specified.
   143  *
   144  * @param value			Input value.
   145  * @param base			Logarithm base to use, default is 10.
   146  * @return				log(value)/log(base).
   147  */
   148 native Float:Logarithm(Float:value, Float:base=10.0);
   149 
   150 /**
   151  * Returns the sine of the argument.
   152  *
   153  * @param value			Input value in radians.
   154  * @return				sin(value).
   155  */
   156 native Float:Sine(Float:value);
   157 
   158 /**
   159  * Returns the cosine of the argument.
   160  *
   161  * @param value			Input value in radians.
   162  * @return				cos(value).
   163  */
   164 native Float:Cosine(Float:value);
   165 
   166 /**
   167  * Returns the tangent of the argument.
   168  *
   169  * @param value			Input value in radians.
   170  * @return				tan(value).
   171  */
   172 native Float:Tangent(Float:value);
   173 
   174 /**
   175  * Returns an absolute value.
   176  *
   177  * @param value			Input value.
   178  * @return				Absolute value of the input.
   179  */
   180 native Float:FloatAbs(Float:value);
   181 
   182 /**
   183  * Returns the arctangent of the input value.
   184  *
   185  * @param angle			Input value.
   186  * @return				atan(value) in radians.
   187  */
   188 native Float:ArcTangent(Float:angle);
   189 
   190 /**
   191  * Returns the arccosine of the input value.
   192  *
   193  * @param angle			Input value.
   194  * @return				acos(value) in radians.
   195  */
   196 native Float:ArcCosine(Float:angle);
   197 
   198 /**
   199  * Returns the arcsine of the input value.
   200  *
   201  * @param angle			Input value.
   202  * @return				asin(value) in radians.
   203  */
   204 native Float:ArcSine(Float:angle);
   205 
   206 /**
   207  * Returns the arctangent2 of the input values.
   208  *
   209  * @param x				Horizontal value.
   210  * @param y				Vertical value.
   211  * @return				atan2(value) in radians.
   212  */
   213 native Float:ArcTangent2(Float:x, Float:y);
   214 
   215 /**
   216  * Rounds a floating point number using the "round to nearest" algorithm.
   217  *
   218  * @param value			Floating point value to round.
   219  * @return				The value rounded to the nearest integer.
   220  */
   221 stock RoundFloat(Float:value)
   222 {
   223 	return RoundToNearest(value);
   224 }
   225 
   226 /**
   227  * Backwards compatibility stock.  Do not use.
   228  *
   229  * @deprecated
   230  */
   231 #pragma deprecated Use RoundToNearest() or RoundFloat() instead
   232 stock FloatRound(Float:value)
   233 {
   234 	return RoundToNearest(value);
   235 }
   236 
   237 /**
   238  * User defined operators.
   239  *
   240  */
   241 #pragma rational Float
   242 
   243 native Float:operator*(Float:oper1, Float:oper2) = FloatMul;
   244 native Float:operator/(Float:oper1, Float:oper2) = FloatDiv;
   245 native Float:operator+(Float:oper1, Float:oper2) = FloatAdd;
   246 native Float:operator-(Float:oper1, Float:oper2) = FloatSub;
   247 
   248 stock Float:operator++(Float:oper)
   249 {
   250 	return oper+1.0;
   251 }
   252 
   253 stock Float:operator--(Float:oper)
   254 {
   255 	return oper-1.0;
   256 }
   257 
   258 stock Float:operator-(Float:oper)
   259 {
   260 	return oper^Float:((-1)^((-1)/2));				/* IEEE values are sign/magnitude */
   261 }
   262 
   263 stock Float:operator*(Float:oper1, oper2)
   264 {
   265 	return FloatMul(oper1, float(oper2));			/* "*" is commutative */
   266 }
   267 
   268 stock Float:operator/(Float:oper1, oper2)
   269 {
   270 	return FloatDiv(oper1, float(oper2));
   271 }
   272 
   273 stock Float:operator/(oper1, Float:oper2)
   274 {
   275 	return FloatDiv(float(oper1), oper2);
   276 }
   277 
   278 stock Float:operator+(Float:oper1, oper2)
   279 {
   280 	return FloatAdd(oper1, float(oper2));			/* "+" is commutative */
   281 }
   282 
   283 stock Float:operator-(Float:oper1, oper2)
   284 {
   285 	return FloatSub(oper1, float(oper2));
   286 }
   287 
   288 stock Float:operator-(oper1, Float:oper2)
   289 {
   290 	return FloatSub(float(oper1), oper2);
   291 }
   292 
   293 stock bool:operator==(Float:oper1, Float:oper2)
   294 {
   295 	return FloatCompare(oper1, oper2) == 0;
   296 }
   297 
   298 stock bool:operator==(Float:oper1, oper2)
   299 {
   300 	return FloatCompare(oper1, float(oper2)) == 0; 	/* "==" is commutative */
   301 }
   302 
   303 stock bool:operator!=(Float:oper1, Float:oper2)
   304 {
   305 	return FloatCompare(oper1, oper2) != 0;
   306 }
   307 
   308 stock bool:operator!=(Float:oper1, oper2)
   309 {
   310 	return FloatCompare(oper1, float(oper2)) != 0; 	/* "==" is commutative */
   311 }
   312 
   313 stock bool:operator>(Float:oper1, Float:oper2)
   314 {
   315 	return FloatCompare(oper1, oper2) > 0;
   316 }
   317 
   318 stock bool:operator>(Float:oper1, oper2)
   319 {
   320 	return FloatCompare(oper1, float(oper2)) > 0;
   321 }
   322 
   323 stock bool:operator>(oper1, Float:oper2)
   324 {
   325 	return FloatCompare(float(oper1), oper2) > 0;
   326 }
   327 
   328 stock bool:operator>=(Float:oper1, Float:oper2)
   329 {
   330 	return FloatCompare(oper1, oper2) >= 0;
   331 }
   332 
   333 stock bool:operator>=(Float:oper1, oper2)
   334 {
   335 	return FloatCompare(oper1, float(oper2)) >= 0;
   336 }
   337 
   338 stock bool:operator>=(oper1, Float:oper2)
   339 {
   340 	return FloatCompare(float(oper1), oper2) >= 0;
   341 }
   342 
   343 stock bool:operator<(Float:oper1, Float:oper2)
   344 {
   345 	return FloatCompare(oper1, oper2) < 0;
   346 }
   347 
   348 stock bool:operator<(Float:oper1, oper2)
   349 {
   350 	return FloatCompare(oper1, float(oper2)) < 0;
   351 }
   352 
   353 stock bool:operator<(oper1, Float:oper2)
   354 {
   355 	return FloatCompare(float(oper1), oper2) < 0;
   356 }
   357 
   358 stock bool:operator<=(Float:oper1, Float:oper2)
   359 {
   360 	return FloatCompare(oper1, oper2) <= 0;
   361 }
   362 
   363 stock bool:operator<=(Float:oper1, oper2)
   364 {
   365 	return FloatCompare(oper1, float(oper2)) <= 0;
   366 }
   367 
   368 stock bool:operator<=(oper1, Float:oper2)
   369 {
   370 	return FloatCompare(float(oper1), oper2) <= 0;
   371 }
   372 
   373 stock bool:operator!(Float:oper)
   374 {
   375 	return (_:oper & ((-1)/2)) == 0;		/* -1 = all bits to 1; /2 = remove most significant bit (sign)
   376 											works on both 32bit and 64bit systems; no constant required */
   377 }
   378 
   379 /**
   380  * Forbidden operators.
   381  *
   382  */
   383 forward operator%(Float:oper1, Float:oper2);
   384 forward operator%(Float:oper1, oper2);
   385 forward operator%(oper1, Float:oper2);
   386 
   387 #define FLOAT_PI 3.1415926535897932384626433832795
   388 
   389 /**
   390  * Converts degrees to radians.
   391  *
   392  * @param angle		Degrees.
   393  * @return			Radians.
   394  */
   395 stock Float:DegToRad(Float:angle)
   396 {
   397 	return (angle*FLOAT_PI)/180;
   398 }
   399 
   400 /**
   401  * Converts degrees to radians.
   402  *
   403  * @param angle		Radians.
   404  * @return			Degrees.
   405  */
   406 stock Float:RadToDeg(Float:angle)
   407 {
   408 	return (angle*180)/FLOAT_PI;
   409 }
sourcemod-central
Feed