Podstawowa matematyka
[Base Module]

Classes

class  common::RoundInterpolator< T >
 Interpoluje daną wielkość między wartościami kluczowymi dla parametru w zakresie 0..1 z zawinięciem. More...

Modules

 Maksymalne i minimalne wartości
 Stałe matematyczne
 Szum Perlina

Defines

#define FLOAT_ALMOST_ZERO(F)   ((absolute_cast<uint4>(F) & 0x7f800000L) == 0)
 Liczba zmiennoprzecinkowa bliska zeru.

Functions

bool common::is_finite (float x)
 Zwraca true, jeśli liczba jest niezwyczajna (INF lub NaN).
bool common::is_finite (double x)
 Zwraca true, jeśli liczba jest niezwyczajna (INF lub NaN).
bool common::is_nan (float x)
 Zwraca true, jeśli liczba jest NaN.
bool common::is_nan (double x)
 Zwraca true, jeśli liczba jest NaN.
template<typename T >
common::safe_add (T a, T b)
 Dodaje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.
template<typename T >
common::safe_sub (T a, T b)
 Odejmuje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.
template<typename T >
common::safe_mul (T a, T b)
 Mnoży dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.
float common::safe_acos (float x)
 Bezpieczny arcus cosinus, ogranicza zakres wejściowy do -1...+1 zwracając w razie przekrocznia skrajne wartości wyniku.
int common::round (float x)
 Zaokrągla liczbę, zamiast ją obcinać.
int common::round (double x)
template<typename T >
common::ceil_div (T x, T y)
 Dzieli 2 liczby całkowite zaokrąglając wynik w górę.
template<typename T >
common::AlignUp (T val, T align)
 Aligns given value up to nearest multiply of align value. For example: AlignUp(11, 8) = 16. Use types like uint4, uint8 as T.
template<typename T >
common::AlignDown (T val, T align)
 Aligns given value down to nearest multiply of align value. For example: AlignUp(19, 8) = 16. Use types like uint4, uint8 as T.
template<typename T >
common::round_div (T x, T y)
 Dzielenie z zaokrągleniem matematycznie do najbliższej.
bool common::around (float x, float epsilon)
 Zwraca true, jeśli liczba leży w epsilonowym otoczeniu zera.
bool common::around (double x, double epsilon)
bool common::around (float x, float y, float epsilon)
 Zwraca true, jeśli liczba leży w epsilonowym otoczeniu drugiej liczby.
bool common::around (double x, double y, double epsilon)
bool common::float_equal (float x, float y)
 Zwraca true, jeśli dwie liczby zmiennoprzecinkowe są praktycznie równe.
bool common::double_equal (double x, double y)
template<typename T >
common::sqr (T v)
 Liczy kwadrat liczby.
template<typename T >
common::sign (T v)
 Zwraca znak podanej liczby całkowitej, czyli -1 0 lub 1.
template<typename T >
common::MergeBits (T a, T b, T Mask)
 Łączy bity dwóch liczb wg maski, tzn. wybiera z A te bity, które w masce mają 0 i z B te bity, które w masce mają 1.
template<typename T >
uint common::CountBitsSet (T v)
 Zwraca liczbę bitów, które są jedynką.
template<>
uint common::CountBitsSet< uint > (unsigned v)
uint common::CalcParity (uint v)
 Oblicza bit parzystości liczby.
uint8 common::CalcParity (uint8 v)
 Oblicza bit parzystości liczby.
template<typename T >
common::SwapBitSequences (T v, uint SrcBit, uint DstBit, uint NumBits)
 Zamienia miejscami ciąg bitów w liczbie.
template<typename T >
bool common::IsPow2 (T x)
 Zwraca true, jeśli podana liczba jest potęgą dwójki.
uint4 common::GetBitMask (uint4 n)
 Zwraca maskę bitową z ustawionymi na jedynkę n najmłodszymi bitami.
uint common::log2u (uint v)
 Zwraca logarytm dwójkowy z podanej liczby całkowitej bez znaku, tzn numer najstarszego niezerowego bitu.
uint common::log10u (uint v)
 Zwraca logarytm dziesiętny z podanej liczby całkowitej bez znaku, tzn numer najstarszej cyfry dziesiętnej.
uint common::next_pow2 (uint v)
 Zwraca najmniejszą potęgę dwójki większą lub równą podanej liczbie.
uint common::InterleaveBits (uint a, uint b)
 Przeplata młodsze 16 bitów a (do parzystych) i młodsze 16 bitów b (do nieparzystych) do liczby wynikowej.
uint common::Extend10BitsBy2Zeros (uint n)
uint common::Extend16BitsBy1Zero (uint n)
template<typename T >
common::powi (T a, uint4 b)
 Liczy potęge o całkowitym wykładniku (bardzo szybko!).
template<typename T , typename Predicate >
void common::Sort2 (T &v1, T &v2, Predicate comp)
template<typename T >
void common::Sort2 (T &v1, T &v2)
template<typename T , typename Predicate >
void common::Sort3 (T &v1, T &v2, T &v3, Predicate comp)
template<typename T >
void common::Sort3 (T &v1, T &v2, T &v3)
template<typename T >
common::max3 (const T &a, const T &b, const T &c)
 Zwraca największą z podanych 3 liczb.
template<typename T >
common::min3 (const T &a, const T &b, const T &c)
 Zwraca najmniejszą z podanych 3 liczb.
template<typename T >
common::minmax (const T &a, const T &x, const T &b)
 Zwraca liczbę x ograniczoną do podanego zakresu od a do b.
float common::saturate (float x)
double common::saturate (double x)
float common::trunc (float x)
 Zwraca część całkowitą liczby wraz ze znakiem.
double common::trunc (double x)
float common::frac (float x)
 Zwraca część ułamkową liczby wraz ze znakiem.
double common::frac (double x)
void common::sincos (float angle, float *sine, float *cosine)
 Oblicza sinus i cosinus za jednym zamachem. Może być szybsze, niż liczenie osobno.
float common::Lerp (float x, float y, float t)
 Interpolacja liniowa 1D (t = 0..1).
void common::Lerp (float *out, float x, float y, float t)
float common::SafeLerp (float x, float y, float t)
 Interpolacja liniowa 1D (t jest ograniczane do 0..1).
float common::Lerp2D (float x11, float x21, float x12, float x22, float tx, float ty)
 Interpolacja liniowa 2D.
float common::NormalizeAngle (float angle)
 Normalizuje kąt do przedziału < 0..2PI ).
float common::NormalizeAngle2 (float Angle)
 Normalizuje kąt do przedziału -PI..+PI.
float common::DegToRad (float Angle)
 Przelicza kąt ze stopni na radiany.
float common::RadToDeg (float Angle)
 Przelicza kąt z radianów na stopnie.
float common::AngleDiff (float A, float B)
 Oblicza różnicę kątów A-B, gdzie A, B należą do: 0..2*PI.
float common::EaseCurve (float x)
 Krzywa wygładzona 0..1 -> 0..1: e(x) = 3*x^2 - 2*x^3.
float common::EaseCurve2 (float x)
float common::smoothstep (float min, float max, float x)
 Returns 0.0 if x <= min and 1.0 if x >= max and performs smooth Hermite interpolation between 0 and 1 when min < x < max.
void common::SmoothCD (float *InOutPos, float Dest, float *InOutVel, float SmoothTime, float TimeDelta)
 Funkcja wygładzająca - Critically Damped Smoothing.
void common::SmoothCD (float *InOutPos, float Dest, float *InOutVel, float SmoothTime, float TimeDelta, float MaxSpeed)
float common::Trapezoidal (float x, float a, float b, float c, float d)
 Zwraca liczbę z przedziału 0..1, zależnie od wartości x względem brzegów trapezu a, b, c, d.
float common::Trapezoidal (float x, float a, float b, float c, float d, float min, float max)
 Jak Trapezoidal(), ale zamiast 0..1 zwraca liczbę z przedziału min..max.
int common::QuadraticEquation (float a, float b, float c, float *Out_x1, float *Out_x2)
 Równanie kwadratowe a*x^2 + b*x + c = 0.
void common::CalcMeanAndVariance (const float Numbers[], size_t NumberCount, float *OutMean, float *OutVariance=NULL, bool VarianceBiased=true)
 Oblicza średnią i opcjonalnie wariancję ze zbioru liczb typu float.
void common::CalcMeanAndVariance (const void *NumberData, size_t NumberCount, int NumberStride, float *OutMean, float *OutVariance=NULL, bool VarianceBiased=true)
uint common::MurmurHash (const void *Data, uint DataLen, uint Seed)
 MurmurHash 2.0 - podobno bardzo dobra funkcja hashująca. Dowolne dane binarne. Niestety nie inkrementacyjna.
uint common::SuperFastHash (const void *DataBytes, size_t DataLen)
 Bardzo szybka funkcja hashująca dane.
uint common::WangMix (uint key)
 Hash of 32-bit integer number (uint to uint).
uint common::MakeDEC3 (uint x, uint y, uint z)
uint common::MakeDEC3 (uint x, uint y, uint z, uint w)
uint common::GetXFromDEC3 (uint dec3)
uint common::GetYFromDEC3 (uint dec3)
uint common::GetZFromDEC3 (uint dec3)
uint common::GetWFromDEC3 (uint dec3)
template<typename T >
bool common::CalcLinearFactors (T &outA, T &outB, float x1, float x2, const T &y1, const T &y2)
 Calculates coefficients for linear equation y = A*x + B passing through given points (x1,y1), (x2,y2).
template<typename T >
bool common::CalcQuadraticFactors (T &outA, T &outB, T &outC, float x1, float x2, float x3, const T &y1, const T &y2, const T &y3)
 Calculates coefficients for quadratic equation y = A*x^2 + B*x + C passing through given points (x1,y1), (x2,y2), (x3,y3).
void common::RoundInterpolator::Calc (T *Out, float t) const

Detailed Description

Sztuczki z bitami opracowane na podstawie: Bit Twiddling Hacks, Sean Eron Anderson, http://www-graphics.stanford.edu/~seander/bithacks.html

Format, który w liczbie 32-bitowej uint koduje 4 komponenty uint jako W2Z10Y10X10. Komponenty x, y, z muszą być w zakresie 10 bitów (0..0x03FF, tzn. 0..1023), a komponent w w zakresie 2 bitów (0..0x03, tzn. 0..3).


Define Documentation

#define FLOAT_ALMOST_ZERO (  )     ((absolute_cast<uint4>(F) & 0x7f800000L) == 0)

Liczba zmiennoprzecinkowa bliska zeru.

O dziwo to makro zamienione na funkcję inline działa wolniej - nigdy nie ufaj optymalizacji kompilatora!


Function Documentation

template<typename T >
T common::AlignDown ( val,
align 
) [inline]

Aligns given value down to nearest multiply of align value. For example: AlignUp(19, 8) = 16. Use types like uint4, uint8 as T.

template<typename T >
T common::AlignUp ( val,
align 
) [inline]

Aligns given value up to nearest multiply of align value. For example: AlignUp(11, 8) = 16. Use types like uint4, uint8 as T.

float common::AngleDiff ( float  A,
float  B 
) [inline]

Oblicza różnicę kątów A-B, gdzie A, B należą do: 0..2*PI.

Uwzględnia przekręcanie się kątów, znajduje więc najkrótszą drogę między nimi.

bool common::around ( double  x,
double  y,
double  epsilon 
) [inline]
bool common::around ( float  x,
float  y,
float  epsilon 
) [inline]

Zwraca true, jeśli liczba leży w epsilonowym otoczeniu drugiej liczby.

bool common::around ( double  x,
double  epsilon 
) [inline]
bool common::around ( float  x,
float  epsilon 
) [inline]

Zwraca true, jeśli liczba leży w epsilonowym otoczeniu zera.

template<typename T >
void common::RoundInterpolator< T >::Calc ( T *  Out,
float  t 
) const [inline, inherited]
template<typename T >
bool common::CalcLinearFactors ( T &  outA,
T &  outB,
float  x1,
float  x2,
const T &  y1,
const T &  y2 
) [inline]

Calculates coefficients for linear equation y = A*x + B passing through given points (x1,y1), (x2,y2).

Returns:
false if calculation not possible because x1 is equal or too close to x2.
void common::CalcMeanAndVariance ( const void *  NumberData,
size_t  NumberCount,
int  NumberStride,
float *  OutMean,
float *  OutVariance = NULL,
bool  VarianceBiased = true 
)
void common::CalcMeanAndVariance ( const float  Numbers[],
size_t  NumberCount,
float *  OutMean,
float *  OutVariance = NULL,
bool  VarianceBiased = true 
)

Oblicza średnią i opcjonalnie wariancję ze zbioru liczb typu float.

sqrt(Variance) to ochylenie standardowe.

Parameters:
Variance Można podać NULL, jeśli nas nie interesuje.
uint8 common::CalcParity ( uint8  v  )  [inline]

Oblicza bit parzystości liczby.

uint common::CalcParity ( uint  v  )  [inline]

Oblicza bit parzystości liczby.

template<typename T >
bool common::CalcQuadraticFactors ( T &  outA,
T &  outB,
T &  outC,
float  x1,
float  x2,
float  x3,
const T &  y1,
const T &  y2,
const T &  y3 
) [inline]

Calculates coefficients for quadratic equation y = A*x^2 + B*x + C passing through given points (x1,y1), (x2,y2), (x3,y3).

Returns:
false if calculation not possible because some x arguments are equal or too close to each other.
template<typename T >
T common::ceil_div ( x,
y 
) [inline]

Dzieli 2 liczby całkowite zaokrąglając wynik w górę.

Jako typ stosować int, uint itp. Działa tylko dla liczb dodatnich. Uważać na przekroczenie zakresu liczby (x+y). (Author: Tarlandil)

template<typename T >
uint common::CountBitsSet ( v  )  [inline]

Zwraca liczbę bitów, które są jedynką.

template<>
uint common::CountBitsSet< uint > ( unsigned  v  )  [inline]
float common::DegToRad ( float  Angle  )  [inline]

Przelicza kąt ze stopni na radiany.

bool common::double_equal ( double  x,
double  y 
) [inline]
float common::EaseCurve ( float  x  )  [inline]

Krzywa wygładzona 0..1 -> 0..1: e(x) = 3*x^2 - 2*x^3.

float common::EaseCurve2 ( float  x  )  [inline]

Lepsza od EaseCurve, bo ma zerową drugą pochodną dla x=0 i x=1.

uint common::Extend10BitsBy2Zeros ( uint  n  ) 
uint common::Extend16BitsBy1Zero ( uint  n  ) 
bool common::float_equal ( float  x,
float  y 
) [inline]

Zwraca true, jeśli dwie liczby zmiennoprzecinkowe są praktycznie równe.

Te funkcje są fajne bo nie trzeba znać epsilona, ale za to jest więcej liczenia. (Autor: Tarlandil)

double common::frac ( double  x  )  [inline]
float common::frac ( float  x  )  [inline]

Zwraca część ułamkową liczby wraz ze znakiem.

(Autor: Tarlandil)

uint4 common::GetBitMask ( uint4  n  ) 

Zwraca maskę bitową z ustawionymi na jedynkę n najmłodszymi bitami.

n musi być z z zakresu 0..32.

uint common::GetWFromDEC3 ( uint  dec3  )  [inline]
uint common::GetXFromDEC3 ( uint  dec3  )  [inline]
uint common::GetYFromDEC3 ( uint  dec3  )  [inline]
uint common::GetZFromDEC3 ( uint  dec3  )  [inline]
uint common::InterleaveBits ( uint  a,
uint  b 
)

Przeplata młodsze 16 bitów a (do parzystych) i młodsze 16 bitów b (do nieparzystych) do liczby wynikowej.

bool common::is_finite ( double  x  ) 

Zwraca true, jeśli liczba jest niezwyczajna (INF lub NaN).

bool common::is_finite ( float  x  ) 

Zwraca true, jeśli liczba jest niezwyczajna (INF lub NaN).

bool common::is_nan ( double  x  ) 

Zwraca true, jeśli liczba jest NaN.

bool common::is_nan ( float  x  ) 

Zwraca true, jeśli liczba jest NaN.

template<typename T >
bool common::IsPow2 ( x  )  [inline]

Zwraca true, jeśli podana liczba jest potęgą dwójki.

T musi być liczbą całkowitą bez znaku - uint1, uint2, uint4, uint8, albo liczbą ze znakiem ale na pewno dodatnią. Dla 0 zwraca true.

void common::Lerp ( float *  out,
float  x,
float  y,
float  t 
) [inline]
float common::Lerp ( float  x,
float  y,
float  t 
) [inline]

Interpolacja liniowa 1D (t = 0..1).

float common::Lerp2D ( float  x11,
float  x21,
float  x12,
float  x22,
float  tx,
float  ty 
) [inline]

Interpolacja liniowa 2D.

tx tyczy się pierwszego indeksu, ty drugiego.

uint common::log10u ( uint  v  ) 

Zwraca logarytm dziesiętny z podanej liczby całkowitej bez znaku, tzn numer najstarszej cyfry dziesiętnej.

Dla zera niezdefiniowany.

uint common::log2u ( uint  v  ) 

Zwraca logarytm dwójkowy z podanej liczby całkowitej bez znaku, tzn numer najstarszego niezerowego bitu.

Innymi słowy, o ile bitów przesunąć w lewo jedynkę żeby otrzymać najstarszą jedynkę podanej liczby. Wartość 0 zwraca dla liczb 0 i 1.

uint common::MakeDEC3 ( uint  x,
uint  y,
uint  z,
uint  w 
) [inline]
uint common::MakeDEC3 ( uint  x,
uint  y,
uint  z 
) [inline]
template<typename T >
T common::max3 ( const T &  a,
const T &  b,
const T &  c 
) [inline]

Zwraca największą z podanych 3 liczb.

template<typename T >
T common::MergeBits ( a,
b,
Mask 
) [inline]

Łączy bity dwóch liczb wg maski, tzn. wybiera z A te bity, które w masce mają 0 i z B te bity, które w masce mają 1.

template<typename T >
T common::min3 ( const T &  a,
const T &  b,
const T &  c 
) [inline]

Zwraca najmniejszą z podanych 3 liczb.

template<typename T >
T common::minmax ( const T &  a,
const T &  x,
const T &  b 
) [inline]

Zwraca liczbę x ograniczoną do podanego zakresu od a do b.

uint common::MurmurHash ( const void *  Data,
uint  DataLen,
uint  Seed 
)

MurmurHash 2.0 - podobno bardzo dobra funkcja hashująca. Dowolne dane binarne. Niestety nie inkrementacyjna.

uint common::next_pow2 ( uint  v  )  [inline]

Zwraca najmniejszą potęgę dwójki większą lub równą podanej liczbie.

Dla v == 0 zwraca 0. Dla v > 0x80000000 wynik jest niezdefiniowany.

float common::NormalizeAngle ( float  angle  )  [inline]

Normalizuje kąt do przedziału < 0..2PI ).

float common::NormalizeAngle2 ( float  Angle  )  [inline]

Normalizuje kąt do przedziału -PI..+PI.

template<typename T >
T common::powi ( a,
uint4  b 
) [inline]

Liczy potęge o całkowitym wykładniku (bardzo szybko!).

T może być dowolną liczbą - int, uint4, float itp. (Autor: Tarlandil)

int common::QuadraticEquation ( float  a,
float  b,
float  c,
float *  Out_x1,
float *  Out_x2 
)

Równanie kwadratowe a*x^2 + b*x + c = 0.

Musi być: a != 0.

  • Brak pierwiastków - zwraca 0, x1 i x2 niezdefiniowane.
  • Jeden pierwiastek - zwraca 1, x1 = x2 = jedyne rozwiązanie.
  • Dwa pierwistki - zwraca 2, x1 to pierwszy pierwiastek, x2 to drugi
float common::RadToDeg ( float  Angle  )  [inline]

Przelicza kąt z radianów na stopnie.

int common::round ( double  x  )  [inline]
int common::round ( float  x  )  [inline]

Zaokrągla liczbę, zamiast ją obcinać.

Tak matematycznie, czyli do góry lub w dół zależnie od części ułamkowej.

template<typename T >
T common::round_div ( x,
y 
) [inline]

Dzielenie z zaokrągleniem matematycznie do najbliższej.

float common::safe_acos ( float  x  )  [inline]

Bezpieczny arcus cosinus, ogranicza zakres wejściowy do -1...+1 zwracając w razie przekrocznia skrajne wartości wyniku.

template<typename T >
T common::safe_add ( a,
b 
) [inline]

Dodaje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.

Jako T używać uint1, uint2, uint4, uint8 (Autor: Tarlandil)

template<typename T >
T common::safe_mul ( a,
b 
) [inline]

Mnoży dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.

Jako T używać uint1, uint2, uint4, uint8 (Autor: Tarlandil)

template<typename T >
T common::safe_sub ( a,
b 
) [inline]

Odejmuje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.

Jako T używać uint1, uint2, uint4, uint8 (Autor: Tarlandil)

float common::SafeLerp ( float  x,
float  y,
float  t 
) [inline]

Interpolacja liniowa 1D (t jest ograniczane do 0..1).

double common::saturate ( double  x  )  [inline]
float common::saturate ( float  x  )  [inline]
template<typename T >
T common::sign ( v  )  [inline]

Zwraca znak podanej liczby całkowitej, czyli -1 0 lub 1.

Stosować dla typów całkowitych ze znakiem, czyli int1, int2, int4, int8.

void common::sincos ( float  angle,
float *  sine,
float *  cosine 
)

Oblicza sinus i cosinus za jednym zamachem. Może być szybsze, niż liczenie osobno.

void common::SmoothCD ( float *  InOutPos,
float  Dest,
float *  InOutVel,
float  SmoothTime,
float  TimeDelta,
float  MaxSpeed 
)
void common::SmoothCD ( float *  InOutPos,
float  Dest,
float *  InOutVel,
float  SmoothTime,
float  TimeDelta 
)

Funkcja wygładzająca - Critically Damped Smoothing.

To jest wyliczane wg równania różniczkowego na jakąśtam sprężynę, dokładnie analitycznie, więc TimeDelta może być dowolnie duże.

Parameters:
[in,out] InOutPos Pozycja przed i po przeliczeniu tego kroku
[in,out] InOutVel Prędkość przed i po przeliczeniu tego kroku
Dest Pozycja docelowa
SmoothTime Współczynnik "bezwładności" w jednostkach czasu
TimeDelta Czas kroku (np. czas od poprzedniej klatki)
MaxSpeed Maksymalna dopuszczalna prędkość (maksymalna odległość na jaką pozycja może nie nadążać?)
float common::smoothstep ( float  min,
float  max,
float  x 
) [inline]

Returns 0.0 if x <= min and 1.0 if x >= max and performs smooth Hermite interpolation between 0 and 1 when min < x < max.

This is useful in cases where you would want a threshold function with a smooth transition. Results are undefined if min >= max.

template<typename T >
void common::Sort2 ( T &  v1,
T &  v2 
) [inline]
template<typename T , typename Predicate >
void common::Sort2 ( T &  v1,
T &  v2,
Predicate  comp 
) [inline]
template<typename T >
void common::Sort3 ( T &  v1,
T &  v2,
T &  v3 
) [inline]
template<typename T , typename Predicate >
void common::Sort3 ( T &  v1,
T &  v2,
T &  v3,
Predicate  comp 
) [inline]
template<typename T >
T common::sqr ( v  )  [inline]

Liczy kwadrat liczby.

Jako T stosować dowolny typ który ma operator *. Ta funkcja przydaje się jeśli w nawiasie jest wyrażenie a nie jedna wartość.

uint common::SuperFastHash ( const void *  DataBytes,
size_t  DataLen 
)

Bardzo szybka funkcja hashująca dane.

Autor: Paul Hsieh, http://www.azillionmonkeys.com/qed/hash.html Niestety nie inkrementacyjna.

template<typename T >
T common::SwapBitSequences ( v,
uint  SrcBit,
uint  DstBit,
uint  NumBits 
) [inline]

Zamienia miejscami ciąg bitów w liczbie.

float common::Trapezoidal ( float  x,
float  a,
float  b,
float  c,
float  d,
float  min,
float  max 
) [inline]

Jak Trapezoidal(), ale zamiast 0..1 zwraca liczbę z przedziału min..max.

float common::Trapezoidal ( float  x,
float  a,
float  b,
float  c,
float  d 
) [inline]

Zwraca liczbę z przedziału 0..1, zależnie od wartości x względem brzegów trapezu a, b, c, d.

    x < a => 0
a < x < b => 0..1
b < x < c => 1
c < x < d => 1..0
d < x     => 0
double common::trunc ( double  x  )  [inline]
float common::trunc ( float  x  )  [inline]

Zwraca część całkowitą liczby wraz ze znakiem.

(Autor: Tarlandil)

uint common::WangMix ( uint  key  )  [inline]

Hash of 32-bit integer number (uint to uint).

Source: "Integer Hash Function", Thomas Wang
http://www.concentric.net/~Ttwang/tech/inthash.htm


Generated on Wed Dec 16 20:44:52 2009 for CommonLib by  doxygen 1.6.1