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 >
T	common::safe_add (T a, T b)
	Dodaje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.
template<typename T >
T	common::safe_sub (T a, T b)
	Odejmuje dwie liczby z ograniczeniem zakresu zamiast zawinięcia przy przepełnieniu.
template<typename T >
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 >
T	common::ceil_div (T x, T y)
	Dzieli 2 liczby całkowite zaokrąglając wynik w górę.
template<typename T >
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 >
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 >
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 >
T	common::sqr (T v)
	Liczy kwadrat liczby.
template<typename T >
T	common::sign (T v)
	Zwraca znak podanej liczby całkowitej, czyli -1 0 lub 1.
template<typename T >
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 >
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 >
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 >
T	common::max3 (const T &a, const T &b, const T &c)
	Zwraca największą z podanych 3 liczb.
template<typename T >
T	common::min3 (const T &a, const T &b, const T &c)
	Zwraca najmniejszą z podanych 3 liczb.
template<typename T >
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) = 3x^2 - 2x^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 ax^2 + bx + 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 = Ax^2 + Bx + 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 ( F ) ((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	(	T	val,
		T	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	(	T	val,
		T	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	(	T	x,
		T	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 ( T 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 ( T 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	(	T	a,
		T	b,
		T	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	(	T	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	(	T	x,
		T	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	(	T	a,
		T	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	(	T	a,
		T	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	(	T	a,
		T	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 ( T 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 ( T 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	(	T	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

Podstawowa matematyka [Base Module]

Classes

Modules

Defines

Functions

Detailed Description

Define Documentation

Function Documentation

Podstawowa matematyka
[Base Module]