GClasses
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::ComplexNumber
 Cexception
 CGClasses::FileHolderCloses a file when this object goes out of scope
 CGClasses::G3dLetterMaker
 CGClasses::G3DMatrixRepresents a 3x3 matrix
 CGClasses::G3DVectorRepresents a 3D vector
 CGClasses::GActionPath
 CGClasses::GActionPathSearchThis 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::GActivationFunctionThe base class for activation functions. Typically, this are sigmoid-shaped functions used to "squash" the output of a network node. These are typically used in conjunction with the GNeuralNet class
 CGClasses::GAgentActionIteratorIterates 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::GAppContains some generally useful functions for launching applications
 CGClasses::GArffAttribute
 CGClasses::GArgReaderParses command-line args and provides methods to conveniently process them
 CGClasses::GAssignmentAn abstract base class defining an assignment between two sets
 CGClasses::GAtomicCycleFinderThis finds all of the atomic cycles (cycles that cannot be divided into two smaller cycles) in a graph
 CGClasses::GBayesNetThis 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::GBezierRepresents a Bezier curve
 CGClasses::GBigIntRepresents an integer of arbitrary size, and provides basic arithmetic functionality. Also contains functionality for implementing RSA symmetric-key cryptography
 CGClasses::GBillboardThis 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::GBillboardWorldThis 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::GBitsContains various functions for bit analysis
 CGClasses::GBitTableRepresents a table of bits
 CGClasses::GBlobIncomingThis 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::GBlobOutgoingThis class is for serializing objects. It is the complement to GBlobIncoming
 CGClasses::GBlobQueueThis 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::GBNNodeThe base class of all nodes in a Bayesian belief network
 CGClasses::GBrandesBetweennessCentralityComputes the number of times that the shortest-path between every pair of points passes over each edge and vertex
 CGClasses::GCameraThis 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::GCategoricalSamplerThis class is for efficiently drawing random values from a categorical distribution with a large number of categories
 CGClasses::GCategoricalSamplerBatch
 CGClasses::GCharSetThis class represents a set of characters
 CGClasses::GChessBoardRepresents the state of a chess board, and provides some basic functionality for implementing a chess game
 CGClasses::GChessMoveIteratorIterates through all the possible moves for the specified color. It iterates through the pieces in a random order. It also iterates through the moves for each piece in a random order, but it will visit each move for the current piece before considering the next piece
 CGClasses::GCollaborativeFilterThe base class for collaborative filtering recommender systems
 CGClasses::GCompressorThis implements a simple compression/decompression algorithm
 CGClasses::GCoordVectorIteratorAn 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::GCryptoThis 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::GCSVParserA 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::GCycleCutThis finds the shortcuts in a table of neighbors and replaces them with INVALID_INDEX
 CGClasses::GDataColSplitterThis class divides a matrix into two parts. The left-most columns are the features. The right-most columns are the labels
 CGClasses::GDataRowSplitterThis 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::GDiffThis 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::GDiffLineThis is a helper struct used by GDiff
 CGClasses::GDijkstraFinds 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::GDirListThis 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::GDistanceMetricThis 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::GDistribution
 CGClasses::GDomA 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::GDomListIteratorThis class iterates over the items in a list node
 CGClasses::GDomNodeRepresents a single node in a DOM
 CGClasses::GDoubleRectRepresents a rectangular region with doubles
 CGClasses::GDynamicPageSession
 CGClasses::GDynamicPageSessionExtension
 CGClasses::GExpectExceptionInstantiating an object of this class specifies that any exceptions thrown during the life of this object should be treated as "expected"
 CGClasses::GExtendedKalmanFilterThis is an implementation of the Extended Kalman Filter. This class is used by alternately calling advance and correct
 CGClasses::GFileContains some useful routines for manipulating files
 CGClasses::GFloatRectRepresents a rectangular region with floats
 CGClasses::GFloydWarshallComputes the shortest-cost path between all pairs of vertices in a graph. Takes O(n^3) time
 CGClasses::GFolderDeserializerThis class complements GFolderSerializer
 CGClasses::GFolderSerializerThis turns a file or a folder (and its contents recursively) into a stream of bytes
 CGClasses::GFourierFourier transform
 CGClasses::GFourierWaveProcessorThis 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::GFunctionThis class represents a math function. (It might be used, for example, in a plotting tool.)
 CGClasses::GFunctionParserThis class parses math equations. (This is useful, for example, for plotting tools.)
 CGClasses::GGraphCutThis 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::GGraphEdgeIteratorIterates over the edges that connect to the specified node
 CGClasses::GHashTableBaseThe base class of hash tables
 CGClasses::GHashTableEnumeratorThis class iterates over the values in a hash table
 CGClasses::GHeapProvides 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::GHistogramGathers values and puts them in bins
 CGClasses::GHtmlThis 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::GHttpClientThis class allows you to get files using the HTTP protocol
 CGClasses::GHttpMultipartParser
 CGClasses::GHttpParamParserA class for parsing the name/value pairs that follow the "?" in a URL
 CGClasses::GHttpServerThis class allows you to implement a simple HTTP daemon
 CGClasses::GImageRepresents an image
 CGClasses::GImageJittererGiven an image encoded as a rasterized row of channel values, this class computes a single pixel drawn from the image as if the image had been rotated, translated, and zoomed by a small random amount. (The purpose of this class is to make it possible to train GUnsupervisedBackProp to understand these common image-based transformations.)
 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::GIndexVecUseful functions for operating on vectors of indexes
 CGClasses::GKernelThe 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::GKeyPair
 CGClasses::GLearnerLibProvides some useful functions for instantiating learning algorithms from the command line
 CGClasses::GLearnerLoaderThis 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::GManifoldThis class stores static methods that are useful for manifold learning
 CGClasses::GMasterThreadManages a pool of GWorkerThread objects. To use this class, first call addWorker one or more times. Then, call doJobs
 CGClasses::GMathProvides some useful math functions
 CGClasses::GMatrixRepresents a matrix or a database table
 CGClasses::GMergeDataHolderThis class guarantees that the rows in b are merged vertically back into a when this object goes out of scope
 CGClasses::GMixtureOfGaussiansThis 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::GNeighborFinderFinds the k-nearest neighbors of any vector in a dataset
 CGClasses::GNeuralNetInverseLayerA helper class used by GNeuralNetPseudoInverse
 CGClasses::GNeuralNetLayerRepresents a layer of neurons in a neural network
 CGClasses::GNeuralNetPseudoInverseApproximates the inverse of a neural network. (This only works well if the neural network is mostly invertible. For example, if the neural network only deviates a little from the identity function, then this will work well. With many interesting problems, this gives very poor results.) Note: This class assumes that the activation functions used within each layer of the neural network are homogeneous
 CGClasses::GNurbsNURBS = Non Uniform Rational B-Spline Periodic = closed loop
 CGClasses::GOptimizerThis 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::GOverrunSentinelPlacing these on the stack can help catch buffer overruns
 CGClasses::GPackageClientThis 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::GPackageConnectionBufThis is a helper class used by GPackageConnection
 CGClasses::GPackageServerThis 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::GParallelOptimizersThis class simplifies simultaneously solving several optimization problems
 CGClasses::GPassiveConsoleThis 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::GPCARotateOnlyPrinciple Component Analysis without the projection. It only rotates axes to align with the first few principal components
 CGClasses::GPipeThis 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::GPlotLabelSpacerIf 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::GPlotLabelSpacerLogarithmicSimilar 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::GPlotWindowThis class makes it easy to plot points and functions on 2D cartesian coordinates
 CGClasses::GPolicyLearnerThis is the base class for algorithms that learn a policy
 CGClasses::GPredictionThis 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::GPriorityQueueAn 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::GPriorityQueueEntryAn internal class used by GPriorityQueue. You should not use this class directly
 CGClasses::GProgressEstimatorThis 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::GRandThis is a 64-bit pseudo-random number generator
 CGRand
 CGClasses::GRandomIndexIteratorThis class iterates over all the integer values from 0 to length-1 in random order
 CGClasses::GRayTraceBoundingBoxBaseA class used for making ray-tracing faster
 CGClasses::GRayTraceColorThis 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::GRayTraceLightRepresents a source of light in a ray-tracing scene
 CGClasses::GRayTraceMaterial
 CGClasses::GRayTraceObjectAn object in a ray-tracing scene
 CGClasses::GRayTraceSceneRepresents a scene that you can ray-trace
 CGClasses::GRayTraceTriMeshRepresents a triangle mesh in a ray-tracing scene
 CGClasses::GRecommenderLib
 CGClasses::GRectRepresents a rectangular region with integers
 CGClasses::GRegionAjacencyGraphThe base class for region ajacency graphs. These are useful for breaking down an image into patches of similar color
 CGClasses::GRegionAreaIteratorIterates 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::GRegionBorderIteratorIterates 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::GRelationHolds the metadata for a dataset
 CGClasses::GRelationalElement< T >
 CGClasses::GRelationalRow< T >
 CGClasses::GRelationalTable< T, Comp >
 CGClasses::GReleaseDataHolderThis is a special holder that guarantees the data set will release all of its data before it is deleted
 CGClasses::GRubberBallSwarmThis is an algorithm for finding good starting points within a constrained optimization problem. It works by simulating "rubber balls" which bounce around inside the constrained region. After many iterations, they tend to be spread somewhat uniformly, even with very complex constrained shapes. The balls learn to approximate the shape of the shell, so if the room is wider than it is tall, the balls will learn to bounce sideways more often than vertically
 CGClasses::GRunningCovarianceComputes a running covariance matrix about the origin
 CGClasses::GSDLA collection of routines that are useful when interfacing with SDL
 CGClasses::GShortcutPrunerThis finds the shortcuts in a table of neighbors and replaces them with INVALID_INDEX
 CGClasses::GSignalHandlerTemporarily 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::GSmtpFor sending email to an SMTP server
 CGClasses::GSparseClustererThis is a base class for clustering algorithms that operate on sparse matrices
 CGClasses::GSparseMatrixThis class stores a row-compressed sparse matrix. That is, each row consists of a map from a column-index to a value
 CGClasses::GSparseSimilarityThe base class for similarity metrics that operate on sparse vectors
 CGClasses::GSparseVecProvides static methods for operating on sparse vectors
 CGClasses::GSpinLockOn Windows, this implements a spin-lock. On Linux, this wraps pthread_mutex
 CGClasses::GSpinLockHolderThis holder takes a lock (if it is non-NULL) when you construct it. It guarantees to release the lock when it is destroyed
 CGClasses::GStemmerThis 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::GStringChopperThis class chops a big string at word breaks so you can display it intelligently on multiple lines
 CGClasses::GSubImageFinderThis class uses Fourier phase correlation to efficiently find sub-images within a larger image
 CGClasses::GSubImageFinder2This class uses heuristics to find sub-images within a larger image. It is slower, but more stable than GSubImageFinder
 CGClasses::GSVGThis class simplifies plotting data to an SVG file
 CGClasses::GSystemLearnerThis is the base class for algorithms that learn to model dynamical systems
 CGClasses::GTargetFunctionThe optimizer seeks to find values that minimize this target function
 CGClasses::GTCPClientThis class is an abstraction of a TCP client socket connection
 CGClasses::GTCPConnectionThis 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::GTCPServerThis class is an abstraction of a TCP server, which maintains a set of socket connections
 CGClasses::GTempBufHelperA helper class used by the GTEMPBUF macro
 CGClasses::GThreadA wrapper for PThreads on Linux and for some corresponding WIN32 api on Windows
 CGClasses::GTimeProvides some time-related functions
 CGClasses::GTokenizerThis 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::GTransducerThis 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::GTransformThis is the base class of algorithms that transform data without supervision
 CGClasses::GTreeNode< T >This is a helper class used by GIndexedMultiSet
 CGClasses::GTreeNode< double >
 CGClasses::GTriMeshBuilder
 CGClasses::GVecContains some useful functions for operating on vectors
 CGClasses::GVecBufHolds an array of doubles that can be resized. This class is slightly lighter-weight than the C++ vector class, and it allows access to the buffer in the form of an array of doubles. Basically, it is useful when working with C-style functions that expect parameters in the form of an array of doubles, rather than as a vector of doubles
 CGClasses::GVocabularyThis 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::GWaveCurrently only supports PCM wave format
 CGClasses::GWaveIteratorThis 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::GWaveletWavelet transform
 CGClasses::GWebSocketClient
 CGClasses::GWeightedModelThis is a helper-class used by GBag
 CGClasses::GWidgetThe base class of all GUI widgets
 CGClasses::GWidgetCommon
 CGClasses::GWordIteratorThis iterates over the words in a block of text
 CGClasses::GWordStatsStores statistics about each word in a GVocabulary
 CGClasses::GWorkerThreadAn 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::HashBucketThis is an internal structure used by GHashTable
 CGClasses::HashTableNodeObjects 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::SOM::NodeA node in a self-organizing map
 CGClasses::SOM::NodeAndDistanceUsed for creating an array of nodes sorted by nearness to a source node
 CGClasses::SOM::NodeLocationInitializationWay 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::NodeWeightInitializationAlgorithm to initialize the weights of the nodes in the network before training
 CGClasses::PathDataHelper struct to hold the results from GFile::ParsePath
 CGClasses::SOM::SVG2DWeightReporter::Point
 CGClasses::SOM::ReporterReports 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::ShouldMaximizeTag class to indicate that the linearAssignment routine should maximize the cost of the assignment
 CGClasses::ShouldMinimizeTag class to indicate that the linearAssignment routine should minimize the cost of the assignment
 CGClasses::smart_ptr< T >A reference-counting smart-pointer
 CGClasses::smart_ptr< GClasses::SOM::Reporter >
 CGClasses::smart_ptr_ref_counter< T >A helper class used by the smart_ptr class
 CGClasses::smart_ptr_ref_counter< GClasses::SOM::Reporter >
 CGClasses::strComp
 CGClasses::SOM::TrainingAlgorithmAn 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
 CUsageNode
 CGClasses::VectorOfPointersHolder< T >Deletes all of the pointers in a vector when this object goes out of scope