rand.h File Reference

#include <cstdlib>
#include <cmath>
#include <ANN/ANN.h>

Include dependency graph for rand.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ANN_RAND   random
#define	ANN_SRAND   srandom
#define	ANN_RAND_MAX   2147483647UL

Functions
void	annUniformPts (ANNpointArray pa, int n, int dim)
void	annGaussPts (ANNpointArray pa, int n, int dim, double std_dev)
void	annCoGaussPts (ANNpointArray pa, int n, int dim, double correlation)
void	annLaplacePts (ANNpointArray pa, int n, int dim)
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)
void	annClusOrthFlats (ANNpointArray pa, int n, int dim, int n_clus, ANNbool new_clust, double std_dev, int max_dim)
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

Macro Definition Documentation

#define ANN_RAND   random

Definition at line 52 of file rand.h.

Referenced by annRan0().

#define ANN_RAND_MAX   2147483647UL

Definition at line 54 of file rand.h.

Referenced by annRan0().

#define ANN_SRAND   srandom

Definition at line 53 of file rand.h.

Referenced by annRan0().

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]);
                }
        }
}

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));
                }
        }
}

Variable Documentation

int annIdum

Definition at line 42 of file rand.cpp.

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