Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

CGClasses::ArrayHolder< T >	Just like Holder, except for arrays
CGClasses::ArrayWrapper
►Cbinary_function
►CGClasses::SOM::NeighborhoodWindowFunction	Function that given a width, and a distance from the center of the neighborhood returns a weight to be used to calculate the influence of neighboring nodes at that distance. For each radius, can tell a distance d (possibly infinity) from the center for which all weights for distances greater than or equal to d will be 0
CGClasses::SOM::GaussianWindowFunction	Uses a unit-height, zero-mean Gaussian weighting with the width as sigma truncated to 0 at 5 standard deviations
CGClasses::SOM::UniformWindowFunction	Uses a unit-height, zero-mean Uniform weighting with the width being the radius of the circle anything beyond width is 0
CGClasses::ComplexNumber
►Cexception
CGClasses::Ex	The class of all exceptions thrown by this library A simple exception object that wraps a string message
CGClasses::FileHolder	Closes a file when this object goes out of scope
CGClasses::G3dLetterMaker
CGClasses::G3DMatrix	Represents a 3x3 matrix
CGClasses::G3DVector	Represents a 3D vector
CGClasses::GActionPath
CGClasses::GActionPathSearch	This is the base class of search algorithms that can only perform a discreet set of actions (as opposed to jumping to anywhere in the search space), and seeks to minimize the error of a path of actions
CGClasses::GActionPathState
►CGClasses::GAgentActionIterator	Iterates through all the actions that are valid in the current state. If actions are continuous or very numerous, this should sample valid actions in a random order. The caller may decide that it has sampled enough at any time
CGClasses::GDiscreteActionIterator	This is a simple and common action iterator that can be used when there is a discrete set of possible actions
CGClasses::GApp	Contains some generally useful functions for launching applications
CGClasses::GArffAttribute
CGClasses::GArgReader	Parses command-line args and provides methods to conveniently process them
►CGClasses::GAssignment	An abstract base class defining an assignment between two sets
CGClasses::GSimpleAssignment	A simple concrete implementation of the GAssignment protocol using std::vector<int>
CGClasses::GAtomicCycleFinder	This finds all of the atomic cycles (cycles that cannot be divided into two smaller cycles) in a graph
CGClasses::GBayesNet	This class provides a platform for Bayesian belief networks. It allocates nodes in its own heap using placement new, so you don't have to worry about deleting the nodes. You can allocate your nodes manually and use them separately from this class if you want, but it is a lot easier if you use this class to manage it all
CGClasses::GBezier	Represents a Bezier curve
CGClasses::GBigInt	Represents an integer of arbitrary size, and provides basic arithmetic functionality. Also contains functionality for implementing RSA symmetric-key cryptography
CGClasses::GBillboard	This is a billboard (a 2-D image in a 3-D world) for use with GBillboardWorld. You can set m_repeatX and/or m_repeatY to make the image repeat across the billboard
CGClasses::GBillboardWorld	This class represents a world of billboards, and provides a rendering engine
CGClasses::GBitReverser_imp< T, numBits >	Template used for reversing numBits of type T. You shouldn't need this, use the function reverseBits
CGClasses::GBitReverser_imp< T, 1 >	Base case of template used for reversing numBits of type T. You shouldn't need this, use the function reverseBits
CGClasses::GBits	Contains various functions for bit analysis
CGClasses::GBitTable	Represents a table of bits
CGClasses::GBlobIncoming	This class is for deserializing blobs. It takes care of Endianness issues and protects against buffer overruns. This class would be particularly useful for writing a network protocol
CGClasses::GBlobOutgoing	This class is for serializing objects. It is the complement to GBlobIncoming
CGClasses::GBlobQueue	This is a special queue for handling blobs that come in and go out in varying sizes. It is particulary designed for streaming things that must travel or be parsed in packets that may differ in size from how they are sent or transmitted
►CGClasses::GBlock	Represents a block of network units (artificial neurons) in a neural network
CGClasses::GBlockConvolutional1D
CGClasses::GBlockConvolutional2D
CGClasses::GBlockFeatureSelector	A linear block with no bias. All weights are constrained to fall between 0 and 1, and to sum to 1. Regularization is implicitly applied during training to drive the weights such that each output will settle on giving a weight of 1 to exactly one input unit
CGClasses::GBlockFuzzy	A block of fuzzy logic units. Treats the inputs as two concatenated vectors, whose corresponding values each form a pair to be combined with fuzzy logic to produce one output value. Example: The input {1,2,3,4,5,6} will apply fuzzy logic to the three pairs {1,4}, {2,5} and {3,6} to produce a vector of 3 output values
CGClasses::GBlockLinear	Standard fully-connected block of weights. Often followed by a GBlockActivation
►CGClasses::GBlockRecurrent	Base class of recurrent blocks
CGClasses::GBlockGRU	A block of Gated Recurrent Units
CGClasses::GBlockLSTM	A classic Long Short Term Memory block (with coupled forget and input gates)
CGClasses::GBlockRestrictedBoltzmannMachine
CGClasses::GBlockSoftExp	A parameterized activation function (a.k.a. adaptive transfer function)
CGClasses::GBlockSparse	A layer with random sparse connections
►CGClasses::GBlockWeightless	The base class of blocks that have no weights
►CGClasses::GBlockActivation	The base class of blocks that apply an activation function, such as tanh, in an element-wise manner
CGClasses::GBlockBentIdentity	Applies the Bent identity element-wise to the input. Equation Plot
CGClasses::GBlockGaussian	Applies the Gaussian function element-wise to the input. Equation Plot
CGClasses::GBlockIdentity	Applies the Identity function element-wise to the input. Serves as a pass-through block of units in a neural network. Equation Plot
CGClasses::GBlockLeakyRectifier	Applies the Leaky rectified linear unit (Leaky ReLU) element-wise to the input. Equation Plot
CGClasses::GBlockLogistic	Applies the Logistic function element-wise to the input. Equation Plot
CGClasses::GBlockRectifier	Applies the Rectified linear unit (ReLU) element-wise to the input. Equation Plot
CGClasses::GBlockScaledTanh	Applies a scaled TanH function element-wise to the input. Equation LeCun et al. suggest scale_in=2/3 and scale_out=1.7159. By carefully matching scale_in and scale_out, the nonlinearity can also be tuned to preserve the mean and variance of its input:
CGClasses::GBlockSigExp	An element-wise nonlinearity block This activation function forms a sigmoid shape by splicing exponential and logarithmic functions together
CGClasses::GBlockSine	Applies the Sinusoid element-wise to the input. Equation Plot
CGClasses::GBlockSoftPlus	Applies the SoftPlus function element-wise to the input. Equation Plot
CGClasses::GBlockSoftRoot	An element-wise nonlinearity block. This function is shaped like a sigmoid, but with both a co-domain and domain that spans the continuous values. At very negative values, it is shaped like y=-sqrt(-2x). Near zero, it is shaped like y=x. At very positive values, it is shaped like y=sqrt(2x)
CGClasses::GBlockTanh	Applies the TanH function element-wise to the input. Equation Plot
CGClasses::GBlockAllPairings	Consumes n values and produces a big vector in the form of two vectors (concatenated together) whose corresponding values form all pairs of inputs, plus each input is also paired with each of "lo" and "hi". Example: If the input is {1,2,3}, then the output will be {1,1,1,1,2,2,2,3,3, 2,3,lo,hi,3,lo,hi,lo,hi}. Thus, if there are n inputs, there will be n(n-1)+4n outputs
CGClasses::GBlockScalarProduct	Treats the input as two concatenated vectors. Multiplies each corresponding pair of values together to produce the output
CGClasses::GBlockScalarSum	Treats the input as two concatenated vectors. Adds each corresponding pair of values together to produce the output
CGClasses::GBlockSwitch	Treats the input as three concatenated vectors: a, b, and c. (The values in 'a' typically fall in the range [0,1].) The output is computed element-wise as a*b + (1-a)*c
CGClasses::GMaxPooling2D
CGClasses::GNeuralNet	GNeuralNet contains GLayers stacked upon each other. GLayer contains GBlocks concatenated beside each other. (GNeuralNet is a type of GBlock, so you can nest.) Each GBlock is an array of differentiable network units (artificial neurons). The user must add at least one GBlock to each GLayer
►CGClasses::GBNNode	The base class of all nodes in a Bayesian belief network
CGClasses::GBNConstant	A node in a belief network that represents a constant value
CGClasses::GBNMath	A node in a belief network that applies some math operation to the output of its one parent node
CGClasses::GBNProduct	A node in a belief network that always returns the product of its parent nodes
CGClasses::GBNSum	A node in a belief network that always returns the sum of its parent nodes
►CGClasses::GBNVariable	The base class of nodes in a belief network that represent variable values
CGClasses::GBNCategorical	A node in a belief network that represents a categorical distribution. Instances of this class can serve as parent-nodes to any GBNVariable node. The child node must specify distribution parameters for every category that the parent node supports (or for every combination of categories if there are multiply categorical parents)
►CGClasses::GBNMetropolisNode	This is the base class for nodes in a belief network that are sampled using the Metropolis algorithm
CGClasses::GBNBeta	A node in a belief network that represents a beta distribution
CGClasses::GBNExponential	A node in a belief network that represents an exponential distribution
CGClasses::GBNGamma	A node in a belief network that represents a gamma distribution
CGClasses::GBNInverseGamma	A node in a belief network that represents an inverse-gamma distribution
CGClasses::GBNLogNormal	A node in a belief network that represents a lognormal distribution
CGClasses::GBNNormal	A node in a belief network that represents a Gaussian, or normal, distribution
CGClasses::GBNPareto	A node in a belief network that represents a Pareto distribution
CGClasses::GBNPoisson	A node in a belief network that represents a Poisson distribution
CGClasses::GBNUniformContinuous	A node in a belief network that represents a uniform continuous distribution
CGClasses::GBNUniformDiscrete	A node in a belief network that represents a uniform discrete distribution
CGClasses::GBrandesBetweennessCentrality	Computes the number of times that the shortest-path between every pair of points passes over each edge and vertex
►CGClasses::GCamera	This camera assumes the canvas is specified in cartesian coordinates. The 3D space is based on a right-handed coordinate system. (So if x goes to the right and y goes up, then z comes out of the screen toward you.)
CGClasses::GRayTraceCamera	Represents the camera for a ray tracing scene
CGClasses::GCategoricalSampler	This class is for efficiently drawing random values from a categorical distribution with a large number of categories
CGClasses::GCategoricalSamplerBatch
CGClasses::GCharSet	This class represents a set of characters
►CGClasses::GCollaborativeFilter	The base class for collaborative filtering recommender systems
CGClasses::GBagOfRecommenders	This class performs bootstrap aggregation with collaborative filtering algorithms
CGClasses::GBaselineRecommender	This class always predicts the average rating for each item, no matter to whom it is making the recommendation. The purpose of this algorithm is to serve as a baseline for comparison
CGClasses::GContentBasedFilter
CGClasses::GContentBoostedCF
CGClasses::GDenseClusterRecommender	This class clusters the rows according to a dense distance metric, then uses the baseline vector in each cluster to make predictions
CGClasses::GInstanceRecommender	This class makes recommendations by finding the nearest-neighbors (as determined by evaluating only overlapping ratings), and assuming that the ratings of these neighbors will be predictive of your ratings
CGClasses::GMatrixFactorization	This factors the sparse matrix of ratings, M, such that M = PQ^T where each row in P gives the principal preferences for the corresponding user, and each row in Q gives the linear combination of those preferences that map to a rating for an item. (Actually, P and Q also contain an extra column added for a bias.) This class is implemented according to the specification on page 631 in Takacs, G., Pilaszy, I., Nemeth, B., and Tikk, D. Scalable collaborative filtering approaches for large recommender systems. The Journal of Machine Learning Research, 10:623–656, 2009. ISSN 1532-4435., except with the addition of learning-rate decay and a different stopping criteria
CGClasses::GSparseClusterRecommender	This class clusters the rows according to a sparse similarity metric, then uses the baseline vector in each cluster to make predictions
CGClasses::GCompressor	This implements a simple compression/decompression algorithm
CGClasses::GConstVecWrapper	This class temporarily wraps a GVec around a const array of doubles. You should take care to ensure this object is destroyed before the array it wraps
►CGClasses::GContext	The base class for the buffers that a thread needs to use (train or predict with) a neural network component
CGClasses::GContextLayer	Contains the buffers that a thread needs to train or use a GLayer. Each thread should use a separate GContextLayer object. Call GLayer::newContext to obtain a new GContextLayer object
CGClasses::GContextNeuralNet	Contains the buffers that a thread needs to train or use a GNeuralNet. Each thread should use a separate GContextNeuralNet object. Call GNeuralNet::newContext to obtain a new GContextNeuralNet object
CGClasses::GContextRecurrent	A special context object for recurrent blocks
►CGClasses::GContextRecurrentInstance	A single instance of a recurrent context that has been unfolded through time
CGClasses::GContextGRU	Context class for GRU blocks
CGClasses::GContextLSTM	Context class for LSTM blocks
CGClasses::GCoordVectorIterator	An iterator for an n-dimensional coordinate vector. For example, suppose you have a 4-dimensional 2x3x2x1 grid, and you want to iterate through its coordinates: (0000, 0010, 0100, 0110, 0200, 0210, 1000, 1010, 1100, 1110, 1200, 1210). This class will iterate over coordinate vectors in this manner. (For 0-dimensional coordinate vectors, it behaves as though the origin is the only valid coordinate.)
CGClasses::GCrypto	This is a symmetric-key block-cypher. It utilizes a 2048-byte internal state which is initialized using the passphrase. It uses repeated applications of sha-512 to advance the internal state, and to generate an 1024-byte pad that it xor's with your data to encrypt or decrypt it. Warning: You use this algorithm at your own risk. Many encryption algorithms eventually turn out to be insecure, and to my knowledge, this algorithm has not yet been extensively scrutinized
CGClasses::GCSVParser	A class for parsing CSV files (or tab-separated files, or whitespace separated files, etc.). (This class does not support Mac line endings, so you should replace all '' with ' ' before using this class if your data comes from a Mac.)
CGClasses::GCycleCut	This finds the shortcuts in a table of neighbors and replaces them with INVALID_INDEX
CGClasses::GDataColSplitter	This class divides a matrix into two parts. The left-most columns are the features. The right-most columns are the labels
CGClasses::GDataPreprocessor	This class facilitates automatic data preprocessing. The constructor requires a dataset and some parameters that specify which portion of the data to use, and how the data should be transformed. A transform will automatically be generated to preprocess the data to meet the specified requirements, and the data will be transformed. Additional datasets can be added with the "add" method. These will be processed by the same transform. The processed data can be retrieved with the "get" method, with an index corresponding to the order of the data
CGClasses::GDataRowSplitter	This class divides a features and labels matrix into two parts by randomly assigning each row to one of the two parts, keeping the corresponding rows together. The rows are shallow-copied. The destructor of this class releases all of the row references
CGClasses::GDiff	This class finds the differences between two text files It is case and whitespace sensitive, but is tolerant of Unix/Windows/Mac line endings. It uses lines as the atomic unit. It accepts matching lines in a greedy manner
CGClasses::GDiffLine	This is a helper struct used by GDiff
CGClasses::GDijkstra	Finds the shortest path from an origin vertex to all other vertices. Implemented with a binary-heap priority-queue. If the graph is sparse on edges, it will run in about O(n log(n)) time. If the graph is dense, it runs in about O(n^2 log(n))
CGClasses::GDirList	This class contains a list of files and a list of folders. The constructor populates these lists with the names of files and folders in the current working directory
►CGClasses::GDistanceMetric	This class enables you to define a distance (or dissimilarity) metric between two vectors. pScaleFactors is an optional parameter (it can be NULL) that lets the calling class scale the significance of each dimension. Distance metrics that do not mix with this concept may simply ignore any scale factors. Typically, classes that use this should be able to assume that the triangle inequality will hold, but do not necessarily enforce the parallelogram law
CGClasses::GDenseCosineDistance	Returns 1 minus the cosine of the angle between the two vectors with the origin
CGClasses::GKernelDistance	Returns 1 minus the cosine of the angle between the two vectors with the origin
CGClasses::GLNormDistance	Interpolates between manhattan distance (norm=1), Euclidean distance (norm=2), and Chebyshev distance (norm=infinity). For nominal attributes, Hamming distance is used
CGClasses::GRowDistance	This uses a combination of Euclidean distance for continuous attributes, and Hamming distance for nominal attributes. In particular, for each attribute, it calculates pA[i]-pB[i], squares it and takes the square root of that sum. For nominal attributes pA[i]-pB[i] is 0 if they are the same and 1 if they are different
►CGClasses::GDistribution
CGClasses::GMultivariateNormalDistribution	A multivariate Normal distribution. It can compute the likelihood of a specified vector, and can also generate random vectors from the distribution
►CGClasses::GUnivariateDistribution	This is the base class for univariate distributions
CGClasses::GBetaDistribution	The Beta distribution
CGClasses::GCategoricalDistribution	This is a distribution that specifies a probability for each value in a set of nominal values
CGClasses::GGammaDistribution	The Gamma distribution
CGClasses::GInverseGammaDistribution	The inverse Gamma distribution
CGClasses::GNormalDistribution	This is the Normal (a.k.a. Gaussian) distribution
CGClasses::GPoissonDistribution	The Poisson distribution
CGClasses::GSoftImpulseDistribution
CGClasses::GUniformDistribution	This is a continuous uniform distribution
CGClasses::GDom	A Document Object Model. This represents a document as a hierarchy of objects. The DOM can be loaded-from or saved-to a file in JSON (JavaScript Object Notation) format. (See http://json.org.) In the future, support for XML and/or other formats may be added
CGClasses::GDomListIterator	This class iterates over the items in a list node
CGClasses::GDomNode	Represents a single node in a DOM
CGClasses::GDoubleRect	Represents a rectangular region with doubles
CGClasses::GDynamicPageSession
CGClasses::GDynamicPageSessionExtension
CGClasses::GExpectException	Instantiating an object of this class specifies that any exceptions thrown during the life of this object should be treated as "expected"
CGClasses::GExtendedKalmanFilter	This is an implementation of the Extended Kalman Filter. This class is used by alternately calling advance and correct
CGClasses::GFile	Contains some useful routines for manipulating files
CGClasses::GFloatRect	Represents a rectangular region with floats
CGClasses::GFloydWarshall	Computes the shortest-cost path between all pairs of vertices in a graph. Takes O(n^3) time
CGClasses::GFolderDeserializer	This class complements GFolderSerializer
CGClasses::GFolderSerializer	This turns a file or a folder (and its contents recursively) into a stream of bytes
CGClasses::GFourier	Fourier transform
CGClasses::GFourierWaveProcessor	This is an abstract class that processes a wave file in blocks. Specifically, it divides the wave file up into overlapping blocks, converts them into Fourier space, calls the abstract "process" method with each block, converts back from Fourier space, and then interpolates to create the wave output
CGClasses::GFunction	This class represents a math function. (It might be used, for example, in a plotting tool.)
CGClasses::GFunctionParser	This class parses math equations. (This is useful, for example, for plotting tools.)
CGClasses::GGraphCut	This implements an optimized max-flow/min-cut algorithm described in "An experimental comparison of min-cut/max-flow algorithms for energy minimization in vision" by Boykov, Y. and Kolmogorov, V. This implementation assumes that edges are undirected
CGClasses::GGraphEdgeIterator	Iterates over the edges that connect to the specified node
►CGClasses::GHashTableBase	The base class of hash tables
CGClasses::GConstStringHashTable	Hash table based on keys of constant strings (or at least strings that won't change during the lifetime of the hash table). It's a good idea to use a GHeap in connection with this class
CGClasses::GConstStringToIndexHashTable	Hash table based on keys of constant strings (or at least strings that won't change during the lifetime of the hash table). It's a good idea to use a GHeap in connection with this class
CGClasses::GHashTable	Implements a typical hash table. (It doesn't take ownership of the objects you add, so you must still delete them yourself.)
CGClasses::GNodeHashTable	This is a hash table that uses any object which inherits from HashTableNode as the key
CGClasses::GHashTableEnumerator	This class iterates over the values in a hash table
CGClasses::GHeap	Provides a heap in which to put strings or whatever you need to store. If you need to allocate space for a lot of small objects, it's much more efficient to use this class than the C++ heap. Plus, you can delete them all by simply deleting the heap. You can't, however, reuse the space for individual objects in this heap
CGClasses::GHiddenMarkovModel
CGClasses::GHistogram	Gathers values and puts them in bins
CGClasses::GHtml	This class is for parsing HTML files. It's designed to be very simple. This class might be useful, for example, for building a web-crawler or for extracting readable text from a web page
CGClasses::GHttpClient	This class allows you to get files using the HTTP protocol
CGClasses::GHttpMultipartParser
CGClasses::GHttpParamParser	A class for parsing the name/value pairs that follow the "?" in a URL
►CGClasses::GHttpServer	This class allows you to implement a simple HTTP daemon
CGClasses::GDynamicPageServer
CGClasses::GImage	Represents an image
CGClasses::GIndexedMultiSet< T >	A multiset class that can be queried by index. It is implemented using a balanced tree structure, so most operations take O(log(n)) time
CGClasses::GIndexedMultiSet< double >
CGClasses::GIndexVec	Useful functions for operating on vectors of indexes
►CGClasses::GKernel	The base class for kernel functions. Classes which implement this must provide an "apply" method that applies the kernel to two vectors. Kernels may be combined together to form a more complex kernel, to which the kernel trick will still apply
CGClasses::GKernelAdd	An addition kernel
CGClasses::GKernelChiSquared	Chi Squared kernel
CGClasses::GKernelExp	The Exponential kernel
CGClasses::GKernelGaussianRBF	A Gaussian RBF kernel
CGClasses::GKernelIdentity	The identity kernel
CGClasses::GKernelMultiply	A multiplication kernel
CGClasses::GKernelNormalize	A Normalizing kernel
CGClasses::GKernelPolynomial	A polynomial kernel
CGClasses::GKernelPow	A power kernel
CGClasses::GKernelScale	A scalar kernel
CGClasses::GKernelTranslate	A translation kernel
CGClasses::GKeyPair
CGClasses::GLayer	GNeuralNet contains GLayers stacked upon each other. GLayer contains GBlocks concatenated beside each other. (GNeuralNet is a type of GBlock.) Each GBlock is an array of differentiable network units (artificial neurons). The user must add at least one GBlock to each GLayer
CGClasses::GLearnerLib	Provides some useful functions for instantiating learning algorithms from the command line
CGClasses::GLearnerLoader	This class is for loading various learning algorithms from a DOM. When any learning algorithm is saved, it calls baseDomNode, which creates (among other things) a field named "class" which specifies the class name of the algorithm. This class contains methods that will recognize any of the classes in this library and load them. If it doesn't recognize a class, it will either return NULL or throw and exception, depending on the flags you pass to the constructor. Obviously this loader won't recognize any classes that you make. Therefore, you should overload the corresponding method in this class with a new method that will first recognize and load your classes, and then call these methods to handle other types
CGClasses::GLinearProgramming
CGClasses::GManifold	This class stores static methods that are useful for manifold learning
CGClasses::GMasterThread	Manages a pool of GWorkerThread objects. To use this class, first call addWorker one or more times. Then, call doJobs
CGClasses::GMath	Provides some useful math functions
CGClasses::GMatrix	Represents a matrix or a database table
CGClasses::GMergeDataHolder	This class guarantees that the rows in b are merged vertically back into a when this object goes out of scope
CGClasses::GMixtureOfGaussians	This class uses Expectency Maximization to find the mixture of Gaussians that best approximates the data in a specified real attribute of a data set
►CGClasses::GNeighborFinder	Finds the k-nearest neighbors of any vector in a dataset
►CGClasses::GNeighborFinderGeneralizing	Finds the k-nearest neighbors (in a dataset) of an arbitrary vector (which may or may not be in the dataset)
CGClasses::GBallTree	An efficient algorithm for finding neighbors. Empirically, this class seems to be a little bit slower than GKdTree
CGClasses::GBruteForceNeighborFinder	Finds neighbors by measuring the distance to all points. This one should work properly even if the distance metric does not support the triangle inequality
CGClasses::GKdTree	An efficient algorithm for finding neighbors
CGClasses::GSparseNeighborFinder	Finds neighbors by measuring the distance to all points using a sparse distance metric
CGClasses::GNeighborGraph	This wraps a neighbor finding algorithm. It caches the queries for neighbors for the purpose of improving runtime performance
►CGClasses::GNeuralNetOptimizer	Optimizes the parameters of a differentiable function using an objective function
CGClasses::GAdamOptimizer	Trains a neural network by ADAM. See Diederik P. Kingma and Jimmy Lei Ba, "Adam: A Method for Stochastic Optimization", 2015
CGClasses::GRMSPropOptimizer	Trains a neural network with RMS-prop
CGClasses::GSGDOptimizer	Trains a neural network by stochastic gradient descent
CGClasses::GNurbs	NURBS = Non Uniform Rational B-Spline Periodic = closed loop
►CGClasses::GObjective	A loss function used to train a differentiable function
CGClasses::GSquaredError	The default loss function is squared error
►CGClasses::GOptimizer	This is the base class of all search algorithms that can jump to any vector in the search space seek the vector that minimizes error
CGClasses::GAnnealing	Perturbs the current vector in a random direction. If it made the vector worse, restores the previous vector. Decays the deviation of perturbation over time
CGClasses::GBouncyBalls
CGClasses::GEmpiricalGradientDescent	This algorithm does a gradient descent by feeling a small distance out in each dimension to measure the gradient. For efficiency reasons, it only measures the gradient in one dimension (which it cycles round-robin style) per iteration and uses the remembered gradient in the other dimensions
CGClasses::GEvolutionaryOptimizer	Uses an evolutionary process to optimize a vector
CGClasses::GGridSearch	This performs a brute-force grid search with uniform sampling over the unit hypercube with increasing granularity. (Your target function should scale the candidate vectors as necessary to cover the desired space.) This grid-search increases the granularity after each pass, and carefully avoids sampling anywhere that it has sampled before
CGClasses::GHillClimber	In each dimension, tries 5 candidate adjustments: a lot smaller, a little smaller, same spot, a little bigger, and a lot bigger. If it picks a smaller adjustment, the step size in that dimension is made smaller. If it picks a bigger adjustment, the step size in that dimension is made bigger
CGClasses::GMinBinSearch	This is a hill climber for semi-linear error surfaces that minimizes testing with an approach like binary-search. It only searches approximately within the unit cube (although it may stray a little outside of it). It is the target function's responsibility to map this into an appropriate space
CGClasses::GMomentumGreedySearch	At each iteration this algorithm moves in only one dimension. If the situation doesn't improve it tries the opposite direction. If both directions are worse, it decreases the step size for that dimension, otherwise it increases the step size for that dimension
CGClasses::GParticleSwarm	An optimization algorithm inspired by flocking birds
CGClasses::GProbeSearch	This is somewhat of a multi-dimensional version of binary-search. It greedily probes the best choices first, but then starts trying the opposite choices at the higher divisions so that it can also handle non-monotonic target functions. Each iteration performs a binary (divide-and-conquer) search within the unit hypercube. (Your target function should scale the candidate vectors as necessary to cover the desired space.) Because the high-level divisions are typically less correlated with the quality of the final result than the low-level divisions, it searches through the space of possible "probes" by toggling choices in the order from high level to low level. In low-dimensional space, this algorithm tends to quickly find good solutions, especially if the target function is somewhat smooth. In high-dimensional space, the number of iterations to find a good solution seems to grow exponentially
CGClasses::GRandomDirectionBinarySearch	This algorithm picks a random direction, then uses binary search to determine how far to step, and repeats
CGClasses::GRandomSearch	At each iteration, this tries a random vector from the unit hypercube. (Your target function should scale the candidate vectors as necessary to cover the desired space.)
CGClasses::GSampleClimber	This is a variant of empirical gradient descent that tries to estimate the gradient using a minimal number of samples. It is more efficient than empirical gradient descent, but it only works well if the optimization surface is quite locally linear
CGClasses::GOverrunSentinel	Placing these on the stack can help catch buffer overruns
►CGClasses::GPackageClient	This class abstracts a client that speaks a home-made protocol that guarantees packages will arrive in the same order and size as when they were sent. This protocol is a simple layer on top of TCP
CGClasses::GDomClient	This is a socket client that sends and receives DOM nodes
CGClasses::GPackageConnectionBuf	This is a helper class used by GPackageConnection
►CGClasses::GPackageServer	This class abstracts a server that speaks a home-made protocol that guarantees packages will arrive in the same order and size as when they were sent. This protocol is a simple layer on top of TCP
CGClasses::GDomServer	This is a socket server that sends and receives DOM nodes
CGClasses::GParallelOptimizers	This class simplifies simultaneously solving several optimization problems
CGClasses::GPassiveConsole	This class provides a non-blocking method for reading characters from stdin. (If there are no characters ready in stdin, it immediately returns '\0'.) The constructor sets flags on the console so that it passes characters to the stream immediately (instead of when Enter is pressed), and so that it doesn't echo the keys (if desired), and it makes stdin non-blocking. The destructor puts all those things back the way they were
CGClasses::GPipe	This class wraps the handle of a pipe. It closes the pipe when it is destroyed. This class is useful in conjunction with GApp::systemExecute for reading from, or writing to, the standard i/o streams of a child process
CGClasses::GPlotLabelSpacer	If you need to place grid lines or labels at regular intervals (like 1000, 2000, 3000, 4000... or 20, 25, 30, 35... or 0, 2, 4, 6, 8, 10...) this class will help you pick where to place the labels so that there are a reasonable number of them, and they all land on nice label values
CGClasses::GPlotLabelSpacerLogarithmic	Similar to GPlotLabelSpacer, except for logarithmic grids. To plot in logarithmic space, set your plot window to have a range from log_e(min) to log_e(max). When you actually plot things, plot them at log_e(x), where x is the position of the thing you want to plot
CGClasses::GPlotWindow	This class makes it easy to plot points and functions on 2D cartesian coordinates
►CGClasses::GPolicyLearner	This is the base class for algorithms that learn a policy
►CGClasses::GQLearner	The base class of a Q-Learner. To use this class, there are four abstract methods you'll need to implement. See also the comment for GPolicyLearner
CGClasses::GIncrementalLearnerQAgent	This is an implementation of GQLearner that uses an incremental learner for its Q-table and a SoftMax (usually pick the best action, but sometimes randomly pick the action) strategy to balance between exploration vs exploitation. To use this class, you need to supply an incremental learner (see the comment for the constructor for more details) and to implement the GetRewardForLastAction method
CGClasses::GPrediction	This class is used to represent the predicted distribution made by a supervised learning algorithm. (It is just a shallow wrapper around GDistribution.) It is used in conjunction with calls to GSupervisedLearner::predictDistribution. The predicted distributions will be either categorical distributions (for nominal values) or Normal distributions (for continuous values)
CGClasses::GPriorityQueue	An implementation of a double-ended heap-based priority queue. (Note that the multimap STL class can also be used to implement a double-ended priority queue, but the STL does not currently provide a heap-based double-ended priority queue, which is asymptotically more efficient for insertions.)
CGClasses::GPriorityQueueEntry	An internal class used by GPriorityQueue. You should not use this class directly
CGClasses::GProgressEstimator	This class is used with big loops to estimate the wall-clock time until completion. It works by computing the running median of the duration of recent iterations, and projecting that duration across the remaining iterations
CGClasses::GRand	This is a 64-bit pseudo-random number generator
►CGRand
CGRandMersenneTwister	A 64-bit pseudo-random number generator based on the Mersenne Twister
CGClasses::GRandomIndexIterator	This class iterates over all the integer values from 0 to length-1 in random order
►CGClasses::GRayTraceBoundingBoxBase	A class used for making ray-tracing faster
CGClasses::GRayTraceBoundingBoxInterior	A class used for making ray-tracing faster
CGClasses::GRayTraceBoundingBoxLeaf	A class used for making ray-tracing faster
CGClasses::GRayTraceColor	This class represents a color. It's more precise than GColor, but takes up more memory. Note that the ray tracer ignores the alpha channel because the material specifies a unique transmission color
►CGClasses::GRayTraceLight	Represents a source of light in a ray-tracing scene
CGClasses::GRayTraceAreaLight	Represents a light source with area
CGClasses::GRayTraceDirectionalLight	Represents directional light in a ray-tracing scene
CGClasses::GRayTracePointLight	Represents a point light in a ray-tracing scene
►CGClasses::GRayTraceMaterial
CGClasses::GRayTraceImageTexture
CGClasses::GRayTracePhysicalMaterial	Represents the material of which an object is made in a ray-tracing scene
►CGClasses::GRayTraceObject	An object in a ray-tracing scene
CGClasses::GRayTraceSphere	A sphere in a ray-tracing scene
CGClasses::GRayTraceTriangle	A single triangle in a ray-tracing scene
CGClasses::GRayTraceScene	Represents a scene that you can ray-trace
CGClasses::GRayTraceTriMesh	Represents a triangle mesh in a ray-tracing scene
CGClasses::GRecommenderLib
CGClasses::GRect	Represents a rectangular region with integers
►CGClasses::GRegionAjacencyGraph	The base class for region ajacency graphs. These are useful for breaking down an image into patches of similar color
CGClasses::G2DRegionGraph	Implements a region adjacency graph for 2D images, and lets you merge similar regions to create a hierarchical breakdown of the image
CGClasses::GRegionAreaIterator	Iterates over all the pixels in an image that have the same color and are transitively adjacent. In other words, if you were to flood-fill a the specified point, this returns all the pixels that would be changed
CGClasses::GRegionBorderIterator	Iterates the border of a 2D region by running around the border and reporting the coordinates of each interior border pixel and the direction to the edge. It goes in a counter-clockwise direction
►CGClasses::GRelation	Holds the metadata for a dataset
►CGClasses::GMixedRelation
CGClasses::GArffRelation	ARFF = Attribute-Relation File Format. This stores richer information than GRelation. This includes a name, a name for each attribute, and names for each supported nominal value
CGClasses::GUniformRelation	A relation with a minimal memory footprint that assumes all attributes are continuous, or all of them are nominal and have the same number of possible values
CGClasses::GRelationalElement< T >
CGClasses::GRelationalRow< T >
CGClasses::GRelationalTable< T, Comp >	See GTree.cpp for an example of how to use this class
CGClasses::GReleaseDataHolder	This is a special holder that guarantees the data set will release all of its data before it is deleted
CGClasses::GRunningCovariance	Computes a running covariance matrix about the origin
CGClasses::GSDL	A collection of routines that are useful when interfacing with SDL
CGClasses::GShortcutPruner	This uses "betweeenness centrality" to find the shortcuts in a table of neighbors and replaces them with INVALID_INDEX
CGClasses::GSignalHandler	Temporarily handles certain signals. (When this object is destroyed, it puts all the signal handlers back the way they were.) Periodically call "check" to see if a signal has occurred
CGClasses::GSimplePriorityQueue< T >	Implements a simple priority queue of objects sorted by a double-precision value
CGClasses::GSmtp	For sending email to an SMTP server
►CGClasses::GSparseClusterer	This is a base class for clustering algorithms that operate on sparse matrices
CGClasses::GKMeansSparse	An implementation of the K-means clustering algorithm
CGClasses::GKMedoidsSparse	An implementation of the K-medoids clustering algorithm for sparse data
CGClasses::GSparseMatrix	This class stores a row-compressed sparse matrix. That is, each row consists of a map from a column-index to a value
►CGClasses::GSparseSimilarity	The base class for similarity metrics that operate on sparse vectors
CGClasses::GCosineSimilarity	This is a similarity metric that computes the cosine of the angle bewtween two sparse vectors
CGClasses::GEuclidSimilarity	This computes the reciprocal of Euclidean distance, where all missing values are simply ignored
CGClasses::GPearsonCorrelation	This is a similarity metric that computes the Pearson correlation between two sparse vectors
CGClasses::GSparseVec	Provides static methods for operating on sparse vectors
CGClasses::GSpinLock	On Windows, this implements a spin-lock. On Linux, this wraps pthread_mutex
CGClasses::GSpinLockHolder	This holder takes a lock (if it is non-NULL) when you construct it. It guarantees to release the lock when it is destroyed
CGClasses::GStemmer	This class just wraps the Porter Stemmer. It finds the stems of words. Examples: "cats"->"cat" "dogs"->"dog" "fries"->"fri" "fishes"->"fish" "pies"->"pi" "lovingly"->"lovingli" "candy"->"candi" "babies"->"babi" "bus"->"bu" "busses"->"buss" "women"->"women" "hasty"->"hasti" "hastily"->"hastili" "fly"->"fly" "kisses"->"kiss" "goes"->"goe" "brought"->"brought" As you can see the stems aren't always real words, but that's okay as long as it produces the same stem for words that have the same etymological roots. Even then it still isn't perfect (notice it got "bus" wrong), but it should still improve analysis somewhat in many cases
CGClasses::GStringChopper	This class chops a big string at word breaks so you can display it intelligently on multiple lines
CGClasses::GSubImageFinder	This class uses Fourier phase correlation to efficiently find sub-images within a larger image
CGClasses::GSubImageFinder2	This class uses heuristics to find sub-images within a larger image. It is slower, but more stable than GSubImageFinder
CGClasses::GSVG	This class simplifies plotting data to an SVG file
►CGClasses::GTargetFunction	The optimizer seeks to find values that minimize this target function
CGClasses::GNeuralNetTargetFunction	A class that facilitates training a neural network with an arbitrary optimization algorithm
CGClasses::GOptimizerBasicTestTargetFunction
CGClasses::OptimizerTargetFunc
CGClasses::GTCPClient	This class is an abstraction of a TCP client socket connection
►CGClasses::GTCPConnection	This class is used by GTCPServer to represent a connection with one of the clients. (If you want to associate some additional objects with each connection, you can inherrit from this class, and overload GTCPServer::makeConnection to return your own custom object.)
►CGClasses::GHttpConnection	Each GHttpConnection represents an HTTP connection between a client and the server. A GHTTPServer is a collection of GHTTPConnection objects. To implement a HTTP server, you will typically override the doGet and doPost methods of this class to generate web pages
CGClasses::GDynamicPageConnection
CGClasses::GPackageConnection	This is a helper class used by GPackageServer. If you implement a custom connection object for a sub-class of GPackageServer, then it should inherrit from this class
CGClasses::GTCPServer	This class is an abstraction of a TCP server, which maintains a set of socket connections
CGClasses::GTempBufHelper	A helper class used by the GTEMPBUF macro
CGClasses::GThread	A wrapper for PThreads on Linux and for some corresponding WIN32 api on Windows
CGClasses::GTime	Provides some time-related functions
CGClasses::GTokenizer	This is a simple tokenizer that reads a file, one token at-a-time. To use it, you should make a child class that defines several character sets. Example:
►CGClasses::GTransducer	This is the base class of supervised learning algorithms (that may or may not have an internal model allowing them to generalize rows that were not available at training time). Note that the literature typically refers to supervised learning algorithms that can't generalize (because they lack an internal hypothesis model) as "Semi-supervised". (You cannot generalize with a semi-supervised algorithm–you have to train again with the new rows.)
CGClasses::GAgglomerativeTransducer	This is a semi-supervised agglomerative clusterer. It can only handle one output, and it must be nominal. All inputs must be continuous. Also, it assumes that all output values are represented in the training set
CGClasses::GGraphCutTransducer	A transduction algorithm that uses a max-flow/min-cut graph-cut algorithm to partition the data until each class is in a separate cluster. Unlabeled points are then assigned the label of the cluster in which they fall
CGClasses::GNeighborTransducer	An instance-based transduction algorithm
►CGClasses::GSupervisedLearner	This is the base class of algorithms that learn with supervision and have an internal hypothesis model that allows them to generalize rows that were not available at training time
CGClasses::GBaselineLearner	Always outputs the label mean (for continuous labels) and the most common class (for nominal labels)
CGClasses::GBucket	When Train is called, this performs cross-validation on the training set to determine which learner is the best. It then trains that learner with the entire training set
CGClasses::GDecisionTree	This is an efficient learning algorithm. It divides on the attributes that reduce entropy the most, or alternatively can make random divisions
►CGClasses::GEnsemble	This is a base-class for ensembles that combine the predictions from multiple weighed models
►CGClasses::GBag	BAG stands for bootstrap aggregator. It represents an ensemble of voting models. Each model is trained with a slightly different training set, which is produced by drawing randomly from the original training set with replacement until we have a new training set of the same size. Each model is given equal weight in the vote
CGClasses::GBayesianModelAveraging	This is an ensemble that uses the bagging approach for training, and Bayesian Model Averaging to combine the models. That is, it trains each model with data drawn randomly with replacement from the original training data. It combines the models with weights proporitional to their likelihood as computed using Bayes' law
CGClasses::GBayesianModelCombination
CGClasses::GBomb	An experimental ensemble technique
CGClasses::GResamplingAdaBoost	This is an implementation of AdaBoost, except instead of using weighted samples, it resamples the training set by giving each sample a probability proportional to its weight. This difference enables it to work with algorithms that do not support weighted samples
CGClasses::GGaussianProcess	A Gaussian Process model. This class was implemented according to the specification in Algorithm 2.1 on page 19 of chapter 2 of http://www.gaussianprocesses.org/gpml/chapters/ by Carl Edward Rasmussen and Christopher K. I. Williams
CGClasses::GIdentityFunction	This is an implementation of the identity function. It might be useful, for example, as the observation function in a GRecurrentModel if you want to create a Jordan network
►CGClasses::GIncrementalLearner	This is the base class of supervised learning algorithms that can learn one row at a time
►CGClasses::GFilter
CGClasses::GAutoFilter
CGClasses::GCalibrator
CGClasses::GFeatureFilter
CGClasses::GLabelFilter
CGClasses::GInstanceTable	This represents a grid of values. It might be useful as a Q-table with Q-learning
CGClasses::GKNN	The k-Nearest Neighbor learning algorithm
CGClasses::GNaiveBayes	A naive Bayes classifier
CGClasses::GNaiveInstance	This is an instance-based learner. Instead of finding the k-nearest neighbors of a feature vector, it finds the k-nearst neighbors in each dimension. That is, it finds n*k neighbors, considering each dimension independently. It then combines the label from all of these neighbors to make a prediction. Finding neighbors in this way makes it more robust to high-dimensional datasets. It tends to perform worse than k-nn in low-dimensional space, and better than k-nn in high-dimensional space. (It may be thought of as a cross between a k-nn instance learner and a Naive Bayes learner. It only supports continuous features and labels (so it is common to wrap it in a Categorize filter which will convert nominal features to a categorical distribution of continuous values)
CGClasses::GNeuralDecomposition
CGClasses::GNeuralNetLearner	A thin wrapper around a GNeuralNet that implements the GIncrementalLearner interface
CGClasses::GReservoirNet	This model uses a randomely-initialized network to map the inputs into a higher-dimensional space, and it uses a layer of perceptrons to learn in this augmented space
CGClasses::GLinearDistribution	A linear regression model that predicts a distribution. (This algorithm also differs from GLinearRegressor in that it computes its model in closed form instead of using a numerical approach to find it. In general, GLinearRegressor seems to be a bit more accurate. Perhaps the method used in this algorithm is not very numerically stable.)
CGClasses::GLinearRegressor	A linear regression model. Let f be a feature vector of real values, and let l be a label vector of real values, then this model estimates l=Bf+e, where B is a matrix of real values, and e is a vector of real values. (In the Wikipedia article on linear regression, B is called "beta", and e is called "epsilon". The approach used by this model to compute beta and epsilon, however, is much more efficient than the approach currently described in that article.)
CGClasses::GMeanMarginsTree	A GMeanMarginsTree is an oblique decision tree specified in Gashler, Michael S. and Giraud-Carrier, Christophe and Martinez, Tony. Decision Tree Ensemble: Small Heterogeneous Is Better Than Large Homogeneous. In The Seventh International Conference on Machine Learning and Applications, Pages 900 - 905, ICMLA '08. 2008. It divides features as follows: It finds the mean and principle component of the output vectors. It divides all the vectors into two groups, one that has a positive dot-product with the principle component (after subtracting the mean) and one that has a negative dot-product with the principle component (after subtracting the mean). Next it finds the average input vector for each of the two groups. Then it finds the mean and principle component of those two vectors. The dividing criteria for this node is to subtract the mean and then see whether the dot-product with the principle component is positive or negative
CGClasses::GPolynomial	This regresses a multi-dimensional polynomial to fit the data
CGClasses::GRandomForest
CGClasses::GSparseInstance	An experimental instance-based learner that prunes attribute-values (or predicates) instead of entire instances. This may be viewed as a form of rule-learning that beings with instance-based learning and then prunes
CGClasses::GWag	This model trains several multi-layer perceptrons, then averages their weights together in an intelligent manner
►CGClasses::GTransform	This is the base class of algorithms that transform data without supervision
CGClasses::GBreadthFirstUnfolding	A manifold learning algorithm that reduces dimensionality in local neighborhoods, and then stitches the reduced local neighborhoods together using the Kabsch algorithm
►CGClasses::GClusterer	The base class for clustering algorithms. Classes that inherit from this class must implement a method named "cluster" which performs clustering, and a method named "whichCluster" which reports which cluster the specified row is determined to be a member of
CGClasses::GAgglomerativeClusterer	This merges each cluster with its closest neighbor. (The distance between clusters is computed as the distance between the closest members of the clusters times (n^b), where n is the total number of points from both clusters, and b is a balancing factor
CGClasses::GFuzzyKMeans	A K-means clustering algorithm where every point has partial membership in each cluster. This algorithm is specified in Li, D. and Deogun, J. and Spaulding, W. and Shuart, B., Towards missing data imputation: A study of fuzzy K-means clustering method, In Rough Sets and Current Trends in Computing, Springer, pages 573–579, 2004
CGClasses::GKMeans	An implementation of the K-means clustering algorithm
CGClasses::GKMedoids	An implementation of the K-medoids clustering algorithm
►CGClasses::GIncrementalTransform	This is the base class of algorithms that can transform data one row at a time without supervision
CGClasses::GAttributeSelector	Generates subsets of data that contain only the most relevant features for predicting the labels. The train method of this class produces a ranked ordering of the feature attributes by training a single-layer neural network, and deselecting the weakest attribute until all attributes have been deselected. The transform method uses only the highest-ranked attributes
CGClasses::GDataAugmenter	This class augments data. That is, it transforms the data according to some provided transformation, and attaches the transformed data as new attributes to the existing data
CGClasses::GDiscretize	This transform uses buckets to convert continuous data into discrete data. It is common to use GFilter to combine this with your favorite modeler (which only supports discrete values) to create a modeler that can also support continuous values as well
CGClasses::GImputeMissingVals
CGClasses::GIncrementalTransformChainer	This wraps two two-way-incremental-transforms to form a single combination transform
CGClasses::GLogify	This transform converts continuous values into logarithmic space
CGClasses::GNoiseGenerator	Just generates Gaussian noise
CGClasses::GNominalToCat	This is sort-of the opposite of discretize. It converts each nominal attribute to a categorical distribution by representing each value using the corresponding row of the identity matrix. For example, if a certain nominal attribute has 4 possible values, then a value of 3 would be encoded as the vector 0 0 1 0. When predictions are converted back to nominal values, the mode of the categorical distribution is used as the predicted value. (This is similar to Weka's NominalToBinaryFilter.)
CGClasses::GNormalize	This transform scales and shifts continuous values to make them fall within a specified range
CGClasses::GPairProduct	Generates data by computing the product of each pair of attributes. This is useful for augmenting data
CGClasses::GPCA	Principal Component Analysis. (Computes the principal components about the mean of the data when you call train. The transformed (reduced-dimensional) data will have a mean about the origin.)
CGClasses::GReservoir	This transforms data by passing it through a multi-layer perceptron with randomely-initialized weights. (This transform automatically converts nominal attributes to categorical as necessary, but it does not normalize. In other words, it assumes that all continuous attributes fall approximately within a 0-1 range.)
CGClasses::GSelfOrganizingMap	An implementation of a Kohonen self-organizing map
CGClasses::GIsomap	Isomap is a manifold learning algorithm that uses the Floyd-Warshall algorithm to compute an estimate of the geodesic distance between every pair of points using local neighborhoods, and then uses classic multidimensional scaling to compute a low-dimensional projection
CGClasses::GLLE	Locally Linear Embedding is a manifold learning algorithm that uses sparse matrix techniques to efficiently compute a low-dimensional projection
CGClasses::GManifoldSculpting	Manifold Sculpting. A non-linear dimensionality reduction algorithm. (See Gashler, Michael S. and Ventura, Dan and Martinez, Tony. Iterative non-linear dimensionality reduction with manifold sculpting. In Advances in Neural Information Processing Systems 20, pages 513–520, MIT Press, Cambridge, MA, 2008.)
CGClasses::GScalingUnfolder	This is a nonlinear dimensionality reduction algorithm loosely inspired by Maximum Variance Unfolding. It iteratively scales up the data, then restores distances between neighbors
CGClasses::GTreeNode< T >	This is a helper class used by GIndexedMultiSet
CGClasses::GTreeNode< double >
CGClasses::GTriMeshBuilder
CGClasses::GVec	Represents a mathematical vector of doubles
CGClasses::GVecWrapper	This class temporarily wraps a GVec around an array of doubles. You should take care to ensure this object is destroyed before the array it wraps
CGClasses::GVocabulary	This is a helper class which is useful for text-mining. It collects words, stems them, filters them through a list of stop-words, and assigns a discrete number to each word
CGClasses::GWave	Currently only supports PCM wave format
CGClasses::GWaveIterator	This class iterates over the samples in a WAVE file. Regardless of the bits-per-sample, this iterator will convert all samples to doubles with a range from -1 to 1
CGClasses::GWavelet	Wavelet transform
CGClasses::GWebSocketClient
CGClasses::GWeightedModel	This is a helper-class used by GBag
►CGClasses::GWidget	The base class of all GUI widgets
►CGClasses::GWidgetAtomic	The base class of all atomic widgets (widgets that are not composed of other widgets)
CGClasses::GWidgetAnimation	An image with multiple frames
CGClasses::GWidgetBulletHole	The easiest way to do bullets is to use the GWidgetBulletGroup class, but if you really want to manage individual bullets yourself, you can use this class to do it
CGClasses::GWidgetCanvas	A painting canvas
CGClasses::GWidgetCheckBox
CGClasses::GWidgetGroupBox	This just draws a rectangular box
CGClasses::GWidgetImageButton	A button with an image on it. The left half of the image is the unpressed image and the right half is the pressed image
CGClasses::GWidgetProgressBar	Automatically determines wether to be horizontal or vertical based on dimensions. Progress ranges from 0 to 1, or from 0 to -1 if you want it to go the other way
CGClasses::GWidgetSliderTab	This widget is not meant to be used by itself. It creates one of the parts of a scroll bar or slider bar
CGClasses::GWidgetTextBox	This is a box in which the user can enter text
CGClasses::GWidgetTextButton	A button with text on it
CGClasses::GWidgetTextLabel	A text label
CGClasses::GWidgetTextTab	Represents a tab (like for tabbed menus, etc.)
CGClasses::GWidgetVCRButton	A button with a common icon on it
CGClasses::GWidgetWave
►CGClasses::GWidgetGroup	The base class of all widgets that are composed of other widgets
CGClasses::GWidgetBulletGroup	This creates a whole group of bullets arranged either horizontally or vertically at regular intervals
CGClasses::GWidgetDialog	A form or dialog
CGClasses::GWidgetFileSystemBrowser
CGClasses::GWidgetGrid
CGClasses::GWidgetHorizScrollBar	Makes a horizontal scroll bar
CGClasses::GWidgetHorizSlider
CGClasses::GWidgetVertScrollBar	Makes a vertical scroll bar
CGClasses::GWidgetVertSlider
CGClasses::GWidgetCommon
CGClasses::GWordIterator	This iterates over the words in a block of text
CGClasses::GWordStats	Stores statistics about each word in a GVocabulary
CGClasses::GWorkerThread	An abstract class for performing jobs. The idea is that you should be able to write the code to perform the jobs, then use it in either a serial or parallel manner. The class you write, that inherits from this one, will typically have additional constructor parameters that pass in any values or data necessary to define the jobs
CGClasses::HashBucket	This is an internal structure used by GHashTable
CGClasses::HashTableNode	Objects used with GNodeHashTable should inherit from this class. They must implement two methods (to hash and compare the nodes)
CGClasses::Holder< T >	This class is very similar to the standard C++ class auto_ptr, except it throws an exception if you try to make a copy of it. This way, it will fail early if you use it in a manner that could result in non-deterministic behavior. (For example, if you create a vector of auto_ptrs, wierd things happen if an oom exception is thrown while resizing the buffer–part of the data will be lost when it reverts back to the original buffer. But if you make a vector of these, it will fail quickly, thus alerting you to the issue.)
CGClasses::GBlockConvolutional2D::Image	Image abstraction to facilitate convolution
CGClasses::SOM::Node	A node in a self-organizing map
CGClasses::SOM::NodeAndDistance	Used for creating an array of nodes sorted by nearness to a source node
►CGClasses::SOM::NodeLocationInitialization	Way of initializing the node positions according to a given topology - for example: points on a grid, on a triangular lattice, or random points in space
CGClasses::SOM::GridTopology	Set the nodes to lie on an integer grid within the given maxima. A grid with 10,10 maximum is assumed to go from 0..9. NOTE: if the difference between a dimensional maximum and the nearest integer is less than 1e-6 then the maximum is taken to be that integer. Otherwise it is taken to be the maximum rounded down
►CGClasses::SOM::NodeWeightInitialization	Algorithm to initialize the weights of the nodes in the network before training
CGClasses::SOM::NodeWeightInitializationTrainingSetSample	Initializes the weights to a random sample of rows from the training set
CGClasses::PathData	Helper struct to hold the results from GFile::ParsePath
CGClasses::SOM::SVG2DWeightReporter::Point
►CGClasses::SOM::Reporter	Reports periodically on the training of a self-organizing map - writing status to a stream every so many seconds or iterations, writing visualizations of the network or the network itself to sequentially named files
CGClasses::SOM::IterationIntervalReporter	Calls its sub-reporter on start, the first iteration of a block of "interval" iterations, and finally on stop
CGClasses::SOM::NoReporting	A reporter that does nothing
CGClasses::SOM::ReporterChain	A ReporterChain contains a list of Reporter objects. When a method is called on the ReporterChain, it calls the same method on each of its sub-objects in turn
CGClasses::SOM::SVG2DWeightReporter	Writes out sequentially numbered svg files giving the weight locations in 2 dimensions of input space connected by a mesh that connects each weight with its nearest neighbors. Writes one file each time newStatus is called and once when stop is called. The output of stop may duplicate the last newStatus's output, but is not guaranteed to
CGClasses::ShouldMaximize	Tag class to indicate that the linearAssignment routine should maximize the cost of the assignment
CGClasses::ShouldMinimize	Tag class to indicate that the linearAssignment routine should minimize the cost of the assignment
CGClasses::strComp
►CGClasses::SOM::TrainingAlgorithm	An algorithm for training self-organizing maps. Before training is started, it is expected that the nodes are allocated and that the geometry of the map has been set by giving each node a position and a distance function. However, the weight vectors and the output dimensionality will be completely overwritten by training
CGClasses::SOM::BatchTraining	Implements the batch training algorithm for self-organizing maps as described in T. Kohonen "Self Organizing Maps" Third Edition, 2001, published by Springer
CGClasses::SOM::DummyTrainingAlgorithm	A training algorithm that throws an exception when train is called - stub for fully serializing training algorithms
CGClasses::SOM::TraditionalTraining	Implments the traditional step-wise training of self-organized maps //TODO: finish this comment
CUsageNode
CGClasses::VectorOfPointersHolder< T >	Deletes all of the pointers in a vector when this object goes out of scope