Library Math


[ Search | Keywords | Classes | Data | Functions ]

Quick Index



Classes

RiInterval
Single continuous interval in R1
RiRandomStrategy
The strategy for creating a set of random numbers.
RiRandom
Encapsulates Random Numbers
RiSamplingStrategy
Takes a RiRandom, and generates N samples points in [0,1)^D based on some strategy.
RiUniformSampling
Create N sample points of dimension D uniform in [0,1)^D
Ri1DJitteredSampling
Create N sample points of dimension 2 jittered on [0,1)^2
Ri2DJitteredSampling
Create N sample points of dimension 2 jittered on [0,1)^2
RiSamplePattern
Generate a set of N samples from [0,1)^D
Ri1DSamplePatternIterator
Cycle through each dimension of an RiSamplePattern
Ri2DSamplePatternIterator
Cycle through each dimension of an RiSamplePattern

Data

const RiReal RI_NAN;
const RiReal RI_INF;

Global Functions

// Set operations
RiInterval operator&(const RiInterval &a, const RiInterval &b);
RiInterval operator|(const RiInterval &a, const RiInterval &b);
// Arithmetic operators
RiInterval operator+(const RiInterval &lhs, const RiInterval &rhs);
RiInterval operator-(const RiInterval &lhs, const RiInterval &rhs);
RiInterval operator*(const RiInterval &lhs, const RiInterval &rhs);
RiInterval operator/(const RiInterval &lhs, RiReal f);
ostream &operator<<(ostream &o, const RiInterval &a);
RiInterval operator&(const RiInterval &a, const RiInterval &b) ;
RiInterval operator|(const RiInterval &a, const RiInterval &b) ;
// Use faster functions when RiReal is a float
// These simply overload the double versions
float sqrt(float f) ;
float cos(float f) ;
float sin(float f) ;
float tan(float f) ;
float acos(float f) ;
float asin(float f) ;
float pow(float f, float exp) ;
float atan2(float a, float b) ;
float fabs(float f) ;
float floor(float f) ;
// Comparisons between RiReals
RiReal RiClamp(RiReal min, RiReal max, RiReal num) ;
RiReal RiMin(RiReal a, RiReal b) ;
RiReal RiMin(RiReal a, RiReal b, RiReal c) ;
RiReal RiMin(RiReal a, RiReal b, RiReal c, RiReal d) ;
RiReal RiMax(RiReal a, RiReal b) ;
RiReal RiMax(RiReal a, RiReal b, RiReal c) ;
RiReal RiMax(RiReal a, RiReal b, RiReal c, RiReal d) ;
bool RiClose(RiReal a, RiReal b, RiReal eps ) ;

RiInterval operator&(const RiInterval &a, const RiInterval &b);

#include "RiInterval.H"

ne RiInterval operator&(const RiInterval &a, const RiInterval &b); ********************************************************* FUNCTION GROUP: Set operations Intersection of two intervals *******************************************************

inline RiInterval  operator&(const RiInterval &a, const RiInterval &b);

Function is currently defined inline.


RiInterval operator|(const RiInterval &a, const RiInterval &b);

#include "RiInterval.H"

Union of two intervals

inline RiInterval  operator|(const RiInterval &a, const RiInterval &b);

Function is currently defined inline.


RiInterval operator+(const RiInterval &lhs, const RiInterval &rhs);

#include "RiInterval.H"

RiInterval operator+(const RiInterval &lhs, const RiInterval &rhs);

RiInterval operator-(const RiInterval &lhs, const RiInterval &rhs);

#include "RiInterval.H"

RiInterval operator-(const RiInterval &lhs, const RiInterval &rhs);

RiInterval operator*(const RiInterval &lhs, const RiInterval &rhs);

#include "RiInterval.H"

RiInterval operator*(const RiInterval &lhs, const RiInterval &rhs);

RiInterval operator/(const RiInterval &lhs, RiReal f);

#include "RiInterval.H"

RiInterval operator/(const RiInterval &lhs, RiReal f);

ostream &operator<<(ostream &o, const RiInterval &a);

#include "RiInterval.H"

eam &operator<<(ostream &o, const RiInterval &a); ********************************************************* FUNCTION GROUP: Output operators Output operator *******************************************************

ostream 	  &operator<<(ostream &o, const RiInterval &a);

RiInterval operator&(const RiInterval &a, const RiInterval &b) ;

#include "RiInterval.H"

ne RiInterval operator&(const RiInterval &a, const RiInterval &b)No documentation available.

inline RiInterval  operator&(const RiInterval &a, const RiInterval &b)
                                                                            
;

Function is currently defined inline.


RiInterval operator|(const RiInterval &a, const RiInterval &b) ;

#include "RiInterval.H"

ne RiInterval operator|(const RiInterval &a, const RiInterval &b)No documentation available.

inline RiInterval  operator|(const RiInterval &a, const RiInterval &b)
                                                                            
;

Function is currently defined inline.


const RiReal RI_NAN;

#include "RiMath.H"

a NaN constant

extern const RiReal RI_NAN;

const RiReal RI_INF;

#include "RiMath.H"

a constant equal to infinity.

extern const RiReal RI_INF;

float sqrt(float f) ;

#include "RiMath.H"

inline float sqrt(float f)
                        
;

Function is currently defined inline.


float cos(float f) ;

#include "RiMath.H"

inline float cos(float f)
                       
;

Function is currently defined inline.


float sin(float f) ;

#include "RiMath.H"

ne float sin(float f)No documentation available.

inline float sin(float f)
                       
;

Function is currently defined inline.


float tan(float f) ;

#include "RiMath.H"

ne float tan(float f)No documentation available.

inline float tan(float f)
                       
;

Function is currently defined inline.


float acos(float f) ;

#include "RiMath.H"

ne float acos(float f)No documentation available.

inline float acos(float f)
                        
;

Function is currently defined inline.


float asin(float f) ;

#include "RiMath.H"

ne float asin(float f)No documentation available.

inline float asin(float f)
                        
;

Function is currently defined inline.


float pow(float f, float exp) ;

#include "RiMath.H"

ne float pow(float f, float exp)No documentation available.

inline float pow(float f, float exp)
                            
;

Function is currently defined inline.


float atan2(float a, float b) ;

#include "RiMath.H"

ne float atan2(float a, float b)No documentation available.

inline float atan2(float a, float b)
                              
;

Function is currently defined inline.


float fabs(float f) ;

#include "RiMath.H"

ne float fabs(float f)

inline float erf(float f)

return ferf(f);

inline float erfc(float f)

return ferfc(f);

inline float fabs(float f)
                        
;

Function is currently defined inline.


float floor(float f) ;

#include "RiMath.H"

ne float floor(float f)No documentation available.

inline float floor(float f)
                         
;

Function is currently defined inline.


RiReal RiClamp(RiReal min, RiReal max, RiReal num) ;

#include "RiMath.H"

ne RiReal RiClamp(RiReal min, RiReal max, RiReal num) ********************************************************* FUNCTION GROUP: Comparisons between RiReals

*******************************************************

inline RiReal RiClamp(RiReal min, RiReal max, RiReal num)
                                                                               
;

Function is currently defined inline.


RiReal RiMin(RiReal a, RiReal b) ;

#include "RiMath.H"

inline RiReal RiMin(RiReal a, RiReal b)
                         ;

Function is currently defined inline.


RiReal RiMin(RiReal a, RiReal b, RiReal c) ;

#include "RiMath.H"

inline RiReal RiMin(RiReal a, RiReal b, RiReal c)
                                    
;

Function is currently defined inline.


RiReal RiMin(RiReal a, RiReal b, RiReal c, RiReal d) ;

#include "RiMath.H"

inline RiReal RiMin(RiReal a, RiReal b, RiReal c, RiReal d)
                                             
;

Function is currently defined inline.


RiReal RiMax(RiReal a, RiReal b) ;

#include "RiMath.H"

inline RiReal RiMax(RiReal a, RiReal b)
                         ;

Function is currently defined inline.


RiReal RiMax(RiReal a, RiReal b, RiReal c) ;

#include "RiMath.H"

inline RiReal RiMax(RiReal a, RiReal b, RiReal c)
                                    
;

Function is currently defined inline.


RiReal RiMax(RiReal a, RiReal b, RiReal c, RiReal d) ;

#include "RiMath.H"

inline RiReal RiMax(RiReal a, RiReal b, RiReal c, RiReal d)
                                             
;

Function is currently defined inline.


bool RiClose(RiReal a, RiReal b, RiReal eps ) ;

#include "RiMath.H"

Compares to RiReals based on an epsilon This function should be moved in with a group of fuzzy compares (for RiReal, RiVector3, Directions, Planes, etc)

inline bool RiClose(RiReal a, RiReal b, RiReal eps = RiRealEpsilon)                                       
;

Function is currently defined inline.


Generated from source by the Cocoon utilities on Fri Feb 25 15:15:33 2000 .