rand.cpp File Reference

Go to the source code of this file.

Functions
double	annRan0 ()
static int	annRanInt (int n)
static double	annRanUnif (double lo, double hi)
static double	annRanGauss ()
static double	annRanLaplace ()
void	annUniformPts (ANNpointArray pa, int n, int dim)
void	annGaussPts (ANNpointArray pa, int n, int dim, double std_dev)
void	annLaplacePts (ANNpointArray pa, int n, int dim)
void	annCoGaussPts (ANNpointArray pa, int n, int dim, double correlation)
void	annCoLaplacePts (ANNpointArray pa, int n, int dim, double correlation)
void	annClusGaussPts (ANNpointArray pa, int n, int dim, int n_clus, ANNbool new_clust, double std_dev)
static void	genOrthFlat (ANNpointArray pa, int n, int dim, double *control, double std_dev)
void	annClusOrthFlats (ANNpointArray pa, int n, int dim, int n_clus, ANNbool new_clust, double std_dev, int max_dim)
static void	genGauss (ANNpointArray pa, int n, int dim, double *center, double *std_dev)
void	annClusEllipsoids (ANNpointArray pa, int n, int dim, int n_clus, ANNbool new_clust, double std_dev_small, double std_dev_lo, double std_dev_hi, int max_dim)
void	annPlanted (ANNpointArray pa, int n, int dim, ANNpointArray src, int n_src, double std_dev)

Variables
int	annIdum = 0
const double	CO_FLAG = 999

Function Documentation

void annClusEllipsoids	(	ANNpointArray	pa,
		int	n,
		int	dim,
		int	n_clus,
		ANNbool	new_clust,
		double	std_dev_small,
		double	std_dev_lo,
		double	std_dev_hi,
		int	max_dim
	)

Definition at line 503 of file rand.cpp.

References annAllocPts(), annDeallocPts(), annRan0(), annRanInt(), annRanUnif(), dim, genGauss(), and std_dev.

Referenced by generatePts().

{
        static ANNpointArray centers = NULL;            // cluster centers
        static ANNpointArray std_dev = NULL;            // standard deviations

        if (centers == NULL || new_clust) {                     // need new cluster centers
                if (centers != NULL)                                    // clusters already exist
                        annDeallocPts(centers);                         // get rid of them
                if (std_dev != NULL)                                    // std deviations already exist
                        annDeallocPts(std_dev);                         // get rid of them

                centers = annAllocPts(n_clus, dim);             // alloc new clusters and devs
                std_dev  = annAllocPts(n_clus, dim);

                for (int i = 0; i < n_clus; i++) {              // gen cluster center coords
                        for (int d = 0; d < dim; d++) {
                                centers[i][d] = (ANNcoord) annRanUnif(-1,1);
                        }
                }
                for (int c = 0; c < n_clus; c++) {              // generate cluster std dev
                        int n_dim = 1 + annRanInt(max_dim); // number of dimensions in flat
                        for (int d = 0; d < dim; d++) {         // generate std dev's
                                                                                                // prob. of picking next dim
                                double Prob = ((double) n_dim)/((double) (dim-d));
                                if (annRan0() < Prob) {                 // add this one to ellipse
                                                                                                // generate random std dev
                                        std_dev[c][d] = annRanUnif(std_dev_lo, std_dev_hi);
                                        n_dim--;                                        // one fewer dim to fill
                                }
                                else {                                                  // don't take this one
                                        std_dev[c][d] = std_dev_small;// use small std dev
                                }
                        }
                }
        }

        int offset = 0;                                                         // next slot to fill
        for (int c = 0; c < n_clus; c++) {                      // generate clusters
                int pick = (n+c)/n_clus;                                // number of points to pick
                                                                                                // generate the points
                genGauss(pa+offset, pick, dim, centers[c], std_dev[c]);
                offset += pick;                                                 // increment offset in array
        }
}

void annClusGaussPts	(	ANNpointArray	pa,
		int	n,
		int	dim,
		int	n_clus,
		ANNbool	new_clust,
		double	std_dev
	)

Definition at line 314 of file rand.cpp.

References annAllocPts(), annDeallocPts(), annRanGauss(), annRanInt(), annRanUnif(), and dim.

Referenced by generatePts().

{
        static ANNpointArray clusters = NULL;// cluster storage

        if (clusters == NULL || new_clust) {// need new cluster centers
                if (clusters != NULL)                   // clusters already exist
                        annDeallocPts(clusters);        // get rid of them
                clusters = annAllocPts(n_clus, dim);
                                                                                // generate cluster center coords
                for (int i = 0; i < n_clus; i++) {
                        for (int d = 0; d < dim; d++) {
                                clusters[i][d] = (ANNcoord) annRanUnif(-1,1);
                        }
                }
        }

        for (int i = 0; i < n; i++) {
                int c = annRanInt(n_clus);                              // generate cluster index
                for (int d = 0; d < dim; d++) {
                  pa[i][d] = (ANNcoord) (std_dev*annRanGauss() + clusters[c][d]);
                }
        }
}

void annClusOrthFlats	(	ANNpointArray	pa,
		int	n,
		int	dim,
		int	n_clus,
		ANNbool	new_clust,
		double	std_dev,
		int	max_dim
	)

Definition at line 408 of file rand.cpp.

References annAllocPts(), annDeallocPts(), annRan0(), annRanInt(), annRanUnif(), CO_FLAG, dim, and genOrthFlat().

Referenced by generatePts().

{
        static ANNpointArray control = NULL;            // control vectors

        if (control == NULL || new_clust) {                     // need new cluster centers
                if (control != NULL) {                                  // clusters already exist
                        annDeallocPts(control);                         // get rid of them
                }
                control = annAllocPts(n_clus, dim);

                for (int c = 0; c < n_clus; c++) {              // generate clusters
                        int n_dim = 1 + annRanInt(max_dim); // number of dimensions in flat
                        for (int d = 0; d < dim; d++) {         // generate side locations
                                                                                                // prob. of picking next dim
                                double Prob = ((double) n_dim)/((double) (dim-d));
                                if (annRan0() < Prob) {                 // add this one to flat
                                        control[c][d] = CO_FLAG;        // flag this entry
                                        n_dim--;                                        // one fewer dim to fill
                                }
                                else {                                                  // don't take this one
                                        control[c][d] = annRanUnif(-1,1);// random value in [-1,1]
                                }
                        }
                }
        }
        int offset = 0;                                                         // offset in pa array
        for (int c = 0; c < n_clus; c++) {                      // generate clusters
                int pick = (n+c)/n_clus;                                // number of points to pick
                                                                                                // generate the points
                genOrthFlat(pa+offset, pick, dim, control[c], std_dev);
                offset += pick;                                                 // increment offset
        }
}

void annCoGaussPts	(	ANNpointArray	pa,
		int	n,
		int	dim,
		double	correlation
	)

Definition at line 250 of file rand.cpp.

References annRanGauss(), and dim.

Referenced by generatePts().

{
        double std_dev_w = sqrt(1.0 - correlation * correlation);
        for (int i = 0; i < n; i++) {
                double previous = annRanGauss();
                pa[i][0] = (ANNcoord) previous;
                for (int d = 1; d < dim; d++) {
                        previous = correlation*previous + std_dev_w*annRanGauss();
                        pa[i][d] = (ANNcoord) previous;
                }
        }
}

void annCoLaplacePts	(	ANNpointArray	pa,
		int	n,
		int	dim,
		double	correlation
	)

Definition at line 273 of file rand.cpp.

References annRan0(), annRanLaplace(), and dim.

Referenced by generatePts().

{
        double wn;
        double corr_sq = correlation * correlation;

        for (int i = 0; i < n; i++) {
                double previous = annRanLaplace();
                pa[i][0] = (ANNcoord) previous;
                for (int d = 1; d < dim; d++) {
                        double temp = annRan0();
                        if (temp < corr_sq)
                                wn = 0.0;
                        else
                                wn = annRanLaplace();
                        previous = correlation * previous + wn;
                        pa[i][d] = (ANNcoord) previous;
                }
        }
}

void annGaussPts	(	ANNpointArray	pa,
		int	n,
		int	dim,
		double	std_dev
	)

Definition at line 214 of file rand.cpp.

References annRanGauss(), dim, and std_dev.

Referenced by generatePts().

{
        for (int i = 0; i < n; i++) {
                for (int d = 0; d < dim; d++) {
                        pa[i][d] = (ANNcoord) (annRanGauss() * std_dev);
                }
        }
}

void annLaplacePts	(	ANNpointArray	pa,
		int	n,
		int	dim
	)

Definition at line 232 of file rand.cpp.

References annRanLaplace(), and dim.

Referenced by generatePts().

{
        for (int i = 0; i < n; i++) {
                for (int d = 0; d < dim; d++) {
                        pa[i][d] = (ANNcoord) annRanLaplace();
                }
        }
}

void annPlanted	(	ANNpointArray	pa,
		int	n,
		int	dim,
		ANNpointArray	src,
		int	n_src,
		double	std_dev
	)

Definition at line 580 of file rand.cpp.

References annRanGauss(), annRanInt(), and dim.

Referenced by generatePts().

{
        for (int i = 0; i < n; i++) {
                int c = annRanInt(n_src);                       // generate source index
                for (int d = 0; d < dim; d++) {
                  pa[i][d] = (ANNcoord) (std_dev*annRanGauss() + src[c][d]);
                }
        }
}

double annRan0

(

)

Definition at line 59 of file rand.cpp.

References annIdum.

Referenced by annClusEllipsoids(), annClusOrthFlats(), annCoLaplacePts(), annRanInt(), annRanLaplace(), and annRanUnif().

{
        const int TAB_SIZE = 97;                        // table size: any large number
        int j;

        static double y, v[TAB_SIZE];
        static int iff = 0;
        const double RAN_DIVISOR = double(ANN_RAND_MAX + 1UL);
        if (RAN_DIVISOR < 0) {
                cout << "RAN_DIVISOR " << RAN_DIVISOR << endl;
                exit(0);
        }

        //--------------------------------------------------------------------
        // As a precaution against misuse, we will always initialize on the
        // first call, even if "annIdum" is not set negative. Determine
        // "maxran", the next integer after the largest representable value
        // of type int. We assume this is a factor of 2 smaller than the
        // corresponding value of type unsigned int.
        //--------------------------------------------------------------------

        if (annIdum < 0 || iff == 0) {          // initialize
                iff = 1;
                ANN_SRAND(annIdum);                             // (re)seed the generator
                annIdum = 1;

                for (j = 0; j < TAB_SIZE; j++)  // exercise the system routine
                        ANN_RAND();                                     // (values intentionally ignored)

                for (j = 0; j < TAB_SIZE; j++)  // then save TAB_SIZE-1 values
                        v[j] = ANN_RAND();
                y = ANN_RAND();                                 // generate starting value
         }

        //--------------------------------------------------------------------
        // This is where we start if not initializing. Use the previously
        // saved random number y to get an index j between 1 and TAB_SIZE-1.
        // Then use the corresponding v[j] for both the next j and as the
        // output number.
        //--------------------------------------------------------------------

        j = int(TAB_SIZE * (y / RAN_DIVISOR));
        y = v[j];
        v[j] = ANN_RAND();                                      // refill the table entry
        return y / RAN_DIVISOR;
}

static double annRanGauss ( )

static

Definition at line 137 of file rand.cpp.

References annRanUnif().

Referenced by annClusGaussPts(), annCoGaussPts(), annGaussPts(), annPlanted(), genGauss(), and genOrthFlat().

{
        static int iset=0;
        static double gset;

        if (iset == 0) {                                        // we don't have a deviate handy
                double v1, v2;
                double r = 2.0;
                while (r >= 1.0) {
                        //------------------------------------------------------------
                        // Pick two uniform numbers in the square extending from -1 to
                        // +1 in each direction, see if they are in the circle of radius
                        // 1.  If not, try again
                        //------------------------------------------------------------
                        v1 = annRanUnif(-1, 1);
                        v2 = annRanUnif(-1, 1);
                        r = v1 * v1 + v2 * v2;
                }
                double fac = sqrt(-2.0 * log(r) / r);
                //-----------------------------------------------------------------
                // Now make the Box-Muller transformation to get two normal
                // deviates.  Return one and save the other for next time.
                //-----------------------------------------------------------------
                gset = v1 * fac;
                iset = 1;                                               // set flag
                return v2 * fac;
        }
        else {                                                          // we have an extra deviate handy
                iset = 0;                                               // so unset the flag
                return gset;                                    // and return it
        }
}

static int annRanInt ( int  n )

static

Definition at line 112 of file rand.cpp.

References annRan0().

Referenced by annClusEllipsoids(), annClusGaussPts(), annClusOrthFlats(), and annPlanted().

{
        int r = (int) (annRan0()*n);
        if (r == n) r--;                                        // (in case annRan0() == 1 or n == 0)
        return r;
}

static double annRanLaplace ( )

static

Definition at line 181 of file rand.cpp.

References annRan0().

Referenced by annCoLaplacePts(), and annLaplacePts().

{
        const double b = 1.4142136;

        double laprand = -log(annRan0()) / b;
        double sign = annRan0();
        if (sign < 0.5) laprand = -laprand;
        return(laprand);
}

static double annRanUnif ( double  lo, double  hi  )

static

Definition at line 124 of file rand.cpp.

References annRan0().

Referenced by annClusEllipsoids(), annClusGaussPts(), annClusOrthFlats(), annRanGauss(), annUniformPts(), and genOrthFlat().

{
        return annRan0()*(hi-lo) + lo;
}

void annUniformPts	(	ANNpointArray	pa,
		int	n,
		int	dim
	)

Definition at line 196 of file rand.cpp.

References annRanUnif(), and dim.

Referenced by generatePts().

{
        for (int i = 0; i < n; i++) {
                for (int d = 0; d < dim; d++) {
                        pa[i][d] = (ANNcoord) (annRanUnif(-1,1));
                }
        }
}

static void genGauss ( ANNpointArray  pa, int  n, int  dim, double *  center, double *  std_dev  )

static

Definition at line 489 of file rand.cpp.

References annRanGauss(), and dim.

Referenced by annClusEllipsoids().

{
        for (int i = 0; i < n; i++) {
                for (int d = 0; d < dim; d++) {
                        pa[i][d] = (ANNcoord) (std_dev[d]*annRanGauss() + center[d]);
                }
        }
}

static void genOrthFlat ( ANNpointArray  pa, int  n, int  dim, double *  control, double  std_dev  )

static

Definition at line 391 of file rand.cpp.

References annRanGauss(), annRanUnif(), CO_FLAG, and dim.

Referenced by annClusOrthFlats().

{
        for (int i = 0; i < n; i++) {                           // generate each point
                for (int d = 0; d < dim; d++) {                 // generate each coord
                        if (control[d] == CO_FLAG)                      // dimension on flat
                                pa[i][d] = (ANNcoord) annRanUnif(-1,1);
                        else                                                            // dimension off flat
                                pa[i][d] = (ANNcoord) (std_dev*annRanGauss() + control[d]);
                }
        }
}

Variable Documentation

int annIdum = 0

Definition at line 42 of file rand.cpp.

Referenced by annRan0(), generatePts(), initGlobals(), and main().

const double CO_FLAG = 999

Definition at line 389 of file rand.cpp.

Referenced by annClusOrthFlats(), and genOrthFlat().