boost  
archive  
DTLib  
CAffine  
CCircleMasks  
CDOG  
CFilterbank  
CGaussKernel  
CHistogram  
CImgVec  
CImg  
CJPEG  
CKMeans  
MATFILE  
CSparsePatImg  
CTextureScale  
ergo  
mh_proposal_result  
kjb  Classes and functions for dealing with trajectory files 
bbb  
Activity_library  
Activity_sequence  
Output_activity  
Get_name  
Get_start  
Get_end  
Get_trajectories  
Activity_sequence_prior  
Group  Group 
Association  
Association_prior  
Data  
Description  
Description_info  Extract sparse information from description (for write()) 
Activity_info  
Description_prior  
Sample_tree  
Endpoint  Class that holds information for endpoints 
Intentional_activity  
Likelihood  
Parameter_prior  
Physical_activity  
Traj_set  
Trajectory  
Trajectory_prior  
Visualizer  Visualize a description and the corresponding data 
debug  
flandmark  
geometry  
gpu  
gui  
Interactive_object  
Selectable  
mcmcda  
Compare_tracks  Functor to compare two tracks. If this were not defined, an association would order its tracks using operator<(pair, pair), which would eventually order by the address of the detection. We use this one to avoid this comparison by address and instead use a value comparison. This way the order will not change every time we read an association 
Association  A class that represents a MCMCDA association 
Data  A class that holds data for the tracking problem 
Association_directory  Later 
Experiment_directory  Later 
Gibbs_proposer  Gibbs proposal mechanism for tracking. Complies with Gibbs proposer concept 
Likelihood  Computes the GPbased likelihood of an association 
Prior  Computes the prior of an MCMCDA association 
Proposer  
Generic_track  A class that represents a generic MCMCDA track 
opencv  
CV_features_to_track_detector  
CV_term_criteria  
opengl  
Glew  
Opengl_callable  
psi  
metrics  
Action  
Action_descriptor  
Entity_state  
Simple_simulator  
Deva_skeleton_boxes  
File_format_exception  
Bbox_pairwise_likelihood  
Bbox_noise_likelihood  
Frame_likelihood  
Model_evaluator  
Cylinder_world_likelihood  
Track_frame_metrics  
Track_metrics  
Model  
Person_flow_blob  A class represent the blob detection based on the optical flow magnitude images 
Progress_recorder  
Psi_step_size  
Psi_body_part  Body parts 
Psi_skeleton  Skeleton class, a vector of body parts 
Skeleton_detection  Skeleton class, a vector of body parts 
Start_state  
Cuboid  
Weighted_box  
pt  
Body_2d  2D body information resulting from projecting the 3D body 
Box_likelihood  Class that represents likelihood of a set of projected boxes given. detections. At the moment it only uses box size and optical flow; in the future, it may be use other data information 
Camera_prior  Class that represents the camera prior 
Color_likelihood  Class that represents color likelihood of a set of projected boxes given detections 
Complete_state  Represents the state of an actor at a frame 
Head  Simple struct representing a head 
Box_data  
Detection_box  Class that represents a detection bounding box from any source 
Direction_prior  Class that represents the prior distribution of a trajectory 
Face_direction_prior  Class that represents the prior distribution of the face direction 
Face_2d  2D face information resulting from projecting the 3D head/face 
Face_flow_likelihood  Class to compute face optical flow likelihood 
Facemark_likelihood  Class to compute facemark likelihood 
Input_directory  Represents the input directory for the people tracking project 
Output_directory  Represents the output directory for the PT tracking project 
Optimize_likelihood  Approximate completedata likelihood via HMC optimziation 
Optical_flow_likelihood  Class to compute face optical flow likelihood 
Position_prior  Class that represents the prior distribution of a trajectory 
Posterior_detail_recorder  Records the details about the posterior 
Propose_person_size  Proposal distribution/mechanism for the size of targets 
Sample_scenes  Use HMC to draw samples from the scene posterior using HMC 
Scene  Class that represents a full scene in the PT universe 
Scene_recorder  Record a series of scenes to a directory 
Write_scene_iterator  Record a series of scenes to a directory 
container_type  Fake container type. Needed for recorder to find the type 
Scene_adapter  Adapts a Scene into a VectorModel for HMC sampling 
Scene_gradient  Wrapper for generic gradient function 
Scene_hessian  Wrapper for generic hessian function 
Gradient_adapter  Wraps Scene_gradient to work with ergo::hmc_step 
Pixel_move  Functor designed to move 3D points by pixels in image plane 
Scene_posterior  Posterior distribution of a scene 
Scene_posterior_ind  Posterior adapter to work with independent gradient computation 
Target  Class that represents a target moving through space 
Propagated_2d_info  Propagated 2D information using optical flow 
Comparator_2d  Comparator for Propagated_2d_info 
Feature_score  
Visibility  Represents the information regarding visibility of an actor at a given frame and given all other actors 
qd  Support for the path algorithm I call the quasiDijkstra method 
Doubly_connected_edge_list  Data structure for a planar subdivision made by edges 
Edge_record  
Face_record  
Vertex_record  
DijkstraPriorityQueue  Pure virtual interface for priority queue in Dijkstra's algorithm 
DoubleCircle  Parameterized circle in the plane 
PixPath_expander  Expand, if possible, a PixPath to fill a specified minimum size 
PixPath  Representation of a sequence of pixel coordinates 
PixPoint  Representation of an (x,y) pair of pixel coordinates 
Is_inbounds  Predicate functor tests whether a PixPoint is in a bounding box 
Unused  Exception thrown if the PixPoint is used while uninitialized 
PolyPath  Open polygonal path with a tangent at each point 
PixPathAc  This is like PixPath except that it has an arclength cache, for teh performance 
RatPoint  Very basic structure to represent X, Y points with rational coords 
PixPoint_line_segment  Basic line segment when endpoints are PixPoints (int coords) 
RatPoint_line_segment  Closed line segment with rational coords 
Redblack_subtree_sum  Balanced binary search tree storing subtree sums in each node 
const_iterator  Iterator class for a tree – lets you access node locators 
StochasticPriorityQueue  Priority queue implementing a stochastic extractnearmin method 
SvgWrap  Class used to render a PixPath as an SVG polygonal path picture 
TopoFusion  This namespace hold structures and code written by Scott Morris 
AutoLayer  RAII approach to the old TopoFusion Layer data structure 
Tile_manager  RAII tool for opening and closing the DOQ master index 
DOrthoQuad  Digital orthoquad buffer 
tile_entry  Data structure for downloaded UTM tiles, like a pt 
Ellipsoid  TopoFusion data structure used to represent an ellipsoid earth 
pt  Definition for a TopoFusion pt 
seg  Old TopoFusion data structure for a sequence of pt structures 
track  Old TopoFusion data structure: metadata for a seg 
waypoint  Definition used for waypoint 
layer  Definition used for layer 
tracking  
Entity_id  Entity + index; used for file I/O 
Generic_trajectory  Represents a trajectory. Vector of optionals to trajectory elements 
Generic_trajectory_map  Represents a set of trajectories; it is a map from entity to trajectory 
Generic_trajectory_element  Represents an element of a trajectory of a particular entity 
Spot_detector  A spot detector functor, comparable to a blob detector 
Palette  Construct some colors, for visualizing grids of numbers 
Calibrated_camera  
Back_projector  
Ground_back_projector  
Parametric_frustum  
Perspective_camera  
Turntable_camera  
Deva_detection  
Compare_box_distance  Functor for comparing box distance 
Deva_facemark  
Face_detection  
Vector_adapter  Default adapter for the hessian function 
Collinear_segment_chain  Represent a collinear line segment, a collinear line segment is inherited from an Line_segment 
Comparable_omap 
 creates an omap from an image that can call compare_omap(compareto) to see how similar it is

Corner  Class to manipulate a 2D corner. The corener is defined in terms of a set of line segments all intersecting at a point in the image, which is the corner position. No consistency controls are performed here 
Edge_point  
Edge  
Edge_set  
Canny_edge_detector  Implements the Canny edge detection algorithm 
Chamfer_transform  
Edge_segment  
Fh_type  
Feature_histogram  
Image_dart  
Features_manager  
Foreground_mask  
Geometric_context  
Hog_responses  
Line_segment_set  Class to manipulate a set of line segments 
Edge_segment_set  Class to manipulate a set of edge segments 
Manhattan_segment  A manhattan segment defined by a line segment and the vanishing point it converges to 
Manhattan_corner_segment  
Manhattan_corner  
Manhattan_world  This class contains the three orthogonal vanishing points defining a Manhattan scene, where most or all planes are aligned with three main orthogonal directions. This class optionally contains a set of segments from the scene, assigned to the correct vanishing point 
Omap_segment  
Omap_computer  
Segment_pair  
Vanishing_point  A vanishing point for a set of parallel lines in an image 
Vanishing_point_detector  This class computes the position of the three vanishing points from a set of line segments. The ass 
Compare_flow_features  Functor to compare two Feature_pair 
Integral_flow  
Ransac_line_fitting  
Rotation_axis  
Calibration_descriptor  
Circle  
Circle_in_3d  
Cylinder  
Cylinder_section  Cylinder_section: a section of a cylinder, specified by angle and position 
Line  Parametric representation of a 2D line in terms of three parameters (a,b,c) (as in ax+by+c = 0) 
Vector_d  
Quaternion  
Transformable  Abstract class to apply a linear transformation to this object 
Glut_parapiped  
Glut_perspective_camera  
Glut_polymesh  
Axis_aligned_rectangle_2d  Class that represents an axisaligned 2D rectangle. It is defined in terms of its (2D) center, its width and its height 
Base_gl_interface  
Parametric_camera_gl_interface  
RenderableObject  
Line_segment  Class to manipulate a line segment The class is parametrized in terms the position of the centre, its length and orientation. This is thus compatible with the output of the Berkeley edge detector. We store also the start point, the end point and the line parameters describing this line segment (for more details on how the line parameters work, please see the class line). This is redundant information, but it is convenient to have all these parameters precomputed and at hand 
Offscreen_buffer  Offscreen rendering buffer 
Matrix_d  
if_then_  
if_then_< false, value1, value2 >  
Frustum  Frustum: a polyhedron of which each torso face is a trapezoid and the top and bottom surfaces are polygons 
Parapiped  Parallelepiped: a hexahedron of which each face is a parallelegram 
Polygon  
GL_Polygon_Renderer  
Polymesh  Abstract class of connected polygons (faces) forming a mesh. We assume that each edge is shared between exactly two faces, that is to say the mesh has to be fully connected 
Polymesh_Plane  This class contains a Vector of plane parameters, a vector of the face indices that lie in the plane, and the polymesh that the faces are from. The plane parameters are the coefficients of a plane of the form ax + by + cz + d = 0 
GL_Polymesh_Renderer  
Rectangle_2d  Class that represents an axisaligned 2D rectangle. It is defined in terms of its (2D) center, its width and its height 
Renderable  Abstract class to render this object with GL 
Wire_renderable  Abstract class to render this object with GL as a wireframe 
Solid_renderable  Abstract class to render this object with GL 
Wire_occlude_renderable  Abstract class to render this object with GL as an occluded wireframe into the depth buffer, to hide unseen lines 
Abstract_renderable  
Generic_renderable  
Generic_renderer  
Renderer  
Wire_renderer  
Wire_occlude_renderer  
Solid_renderer  
Renderer_renderable  
Mv_renderable  Abstract class to render an object that has many possible views 
Mv_generic_renderable  
Mv_wire_occlude_render_wrapper  
Mv_wire_render_wrapper  
Mv_solid_render_wrapper  
Renderable_model  
Right_Triangle_Pair  
Rigid_object  
Sphere  
Triangular_mesh  Triangular_mesh: a polygonal mesh of which each face is a triangle 
Gsl_multifit_fdf  
Gsl_Multimin_fdf  Wrapper for GSL's multidimensional minimizer, when you have gradient 
Gsl_Multimin_f  Wrapper for GSL's multidimensional minimizer, without using gradient 
Generic_multimin  
Gsl_Qrng_basic  Wrapper for one of GSL's quasirandom generators 
Gsl_Qrng_Niederreiter  Quasirandom generator using the algorithm of Bratley et al 
Gsl_Qrng_Sobol  Quasirandom generator using the algorithm of Antonov and Saleev 
Gsl_Qrng_Halton  Quasirandom generator using the algorithm of Halton 
Gsl_Qrng_Rvs_Halton  Quasirandom generator using the algorithm of Vandewoestyne et al 
Gsl_ran_discrete  Randomly sample discrete events with an empirical distribution 
Gsl_rng_basic  Basic RAII wrapper for GNU GSL random number generators 
Gsl_Vector  RAII wrapper for GSL vector objects 
Color_histogram  Class to compute an RGB colour histogram over an image or a rectangular portion of it. The histogram is normalized. We use the same number of bins for each of the channels (r,g,b). It is easy to extend this class so that it computes such histogram over a segment of a shape other than rectangular 
Colormap  
Filter  Filter class 
PixelHSVA  Alternative Pixel using hue, saturation, value, and opacity (alpha) 
Image  Wrapped version of the C struct KJB_image 
Fftw_image_convolution  This is a simple adaptation of Fftw_convolution_2d to Image input 
Opengl_framebuffer_image  
PixelRGBA  Wrapped version of the C struct Pixel, with Alpha (opacity) 
Cloneable  Abstract class to clone this object 
Exception  Base class of all exceptions in the jwsc++ library 
KJB_error  Exception often thrown when wrapped C functions return error codes 
Not_implemented  Object thrown when attempting to use unimplemented functionality 
Runtime_error  Object thrown when computation fails somehow during execution 
Cant_happen  Object thrown when the program does something thought impossible 
Illegal_argument  Object thrown when an argument to a function is not acceptable 
Index_out_of_bounds  Object thrown when an index argument exceeds the size of a container 
Dimension_mismatch  Object thrown when an argument is of the wrong size or dimensions 
Divide_by_zero  Object thrown when an division is attempted with a zero divisor 
Serialization_error  Object thrown when serialization or deserialization fails 
IO_error  Object thrown when input or output fails 
Result_error  Object thrown when a function cannot generate a valid result 
Missing_dependency  Object thrown when a program lacks required resources or libraries 
Option_exception  Object thrown for exceptions related to commandline options 
Missing_option  Object thrown when an obligatory commandline option is absent 
Stack_overflow  Object thrown if a finite size stack is full and pushed farther 
Stack_underflow  Object thrown if stack is empty and popped 
Resource_exhaustion  Object thrown if a resource allocation failed (memory, fp, etc.) 
Increment  Generator that increments (++) its state everytime it is called. Useful for creating sequences of contigous values 
Increase_by  Generator that increases (using +=) itself by the given value everytime it is called 
Index_less_than  Predicate that compares the kth element of a indexable type 
Select_coordinate  Selects a coordinate from a vector type 
Identity  Identity function 
Every_nth_element  Predicate that returns true every nth call 
Compare_address  Predicate that returns true if address of element equals given 
Get_address  Functor that returns the address of a given object 
minimum  
maximum  
Heartbeat  A class for for indicating the status of slowmoving loops 
Index_range  
End_type  
Int_matrix  This class implements matrices, in the linearalgebra sense, restricted to integervalued elements 
Int_vector  This class implements vectors, in the linearalgebra sense, restricted to integervalued elements 
const_circular_iterator  
circular_iterator  
Readable  Abstract class to read this object from an input stream 
Scope_guard  
SerializableConcept  
File_Ptr  RAII wrapper on stdio.h FILE pointers (use a derived class though) 
File_Ptr_Read  RAII wrapper on FILE* used to read a file 
File_Ptr_Write  RAII wrapper on a FILE* used to write to a file 
File_Ptr_Append  RAII wrapper on FILE* used to append a file (write only at the end) 
File_Ptr_Read_Plus  RAII wrapper on FILE* opened with mode "r+" to read and write 
Temporary_File  This class safely opens a temporary file in TEMP_DIR (usually /tmp) 
Temporary_Directory  This class creates a temporary directory under TEMP_DIR (usu. /tmp) 
Temporary_Recursively_Removing_Directory  Create a temp directory that destroys itself with "rm rf" command 
File_Ptr_Smart_Read  This class transparently opens gzipped or bzip2ed files 
to_ptr  Convert to a pointer 
Word_list  Wrapper for the libKJB type Word_list (useful for globs) 
const_iterator  Iterator class used to traverse and read the list 
Writeable  Abstract class to write this object to an output stream 
Pthread_mutex  Dynamically allocated mutex: unlock before you destroy it! 
Pthread_locked_mutex  Same as Pthread_mutex, but starts off in "locked" state 
Mutex_lock  Simple RAII class to grab and release a mutex 
Pthread_attr  RAII class to manage an object of type kjb_pthread_attr_t 
Color_likelihood  Functor that computes the likelihood of a set of projected faces onto an image, using the color distribution of each projected face. More later.. 
compare_point_x_location  
Line_correspondence  
Line_bin  
Compare_edge_segment_starting_points  Compare the corresponding Line_bin based on the x position of the starting point of the image edge segment 
Edge_lines_likelihood  
Correspondence  
Matched_point  
Compare_Normal_Distance  
Point  
Compare_Normal_Distance  
Independent_edge_points_likelihood  
Learned_discrete_prior  This class creates a histogram of a list of points and stores the number of bins in num_bins, the maximum and minimum values allowed in histo_max and histo_min, respectively, and the count of the number of points in each bin in histo_bins, which is a Vector of size num_bins 
Model_edge  
Spline_curve  
Spline_surface  
Nurbs_curve  
Nurbs_surface  
Bezier_curve  
Polybezier_curve  
SimpleVector  
FFTW_Plan2d  RAII class to manage an FFTW plan 
Fftw_convolution_2d  A class for performing 2d convolution using the FFTW library 
Sizes  Utility aggregate stores all sizes – rarely used by caller 
Matrix_traits  
Matrix_traits< int >  
Matrix_traits< double >  
Generic_matrix_view  
Generic_const_matrix_view  
Matrix  This class implements matrices, in the linearalgebra sense, with realvalued elements 
Matrix_stream_io  Static functions to read and write matrix classes with iostream 
Sequence  
Interval_sequence  
Generic_vector_view  
Generic_const_vector_view  
Vector  This class implements vectors, in the linearalgebra sense, with realvalued elements 
Vector_stream_io  Functions to read and write vector classes with streams 
Svd  Tuple that computes a singular value decomposition of a matrix 
Conditional_distribution  A conditional distribution 
Normal_on_normal_dependence  Represents the dependence between X and Y in p(x  y), where (x,y) is a bivariate normal 
MV_normal_on_normal_dependence  Represents the dependence between X and Y in p(x  y), where (x,y) is a multivariate normal 
Geometric_distribution  
Beta_binomial_distribution  
Distribution_traits  Generic traits struct for all distributions 
Categorical_distribution  A categorical distribution 
Distribution_traits< Categorical_distribution< T > >  Traits for the categorical distro 
MV_gaussian_distribution  Multivariate Gaussian (normal) distribution 
Distribution_traits< MV_gaussian_distribution >  Traits for the multivariate normal. Type is kjb::Vector 
Log_normal_distribution  Lognormal distribution 
Distribution_traits< Log_normal_distribution >  
Mixture_distribution  This class implements a mixture distribution. In other words, it is the sum of a finite number of fractions of distributions of the same type (with different parameters) 
Distribution_traits< Mixture_distribution< Distribution > >  Traits for the mixture distro. Type is the type of the mixed distributions 
Uniform_sphere_distribution  
Distribution_traits< Uniform_sphere_distribution< D > >  Traits for the Uniform_sphere_distribution 
Von_mises_fisher_distribution  
Distribution_traits< Von_mises_fisher_distribution< D > >  Traits for the Vonmisesfisher distribution 
Chinese_restaurant_process  
Distribution_traits< Chinese_restaurant_process >  
Histogram  A class that represents a histogram of data. ATM, the data must be doubles 
Histogram_2d  
Weight_array  Forward declarations 
Abstract_dynamics  
Parapiped_camera_dynamics  
Parapiped_stretch_dynamics  
Focal_scale_dynamics  
Discrete_change_size  
Likelihood_dynamics  
Manhattan_hog  
Parametric_parapiped  
Parametric_sphere  
Kriging_interpolator  Class to interpolate elevation values using Gaussian processes 
Ned13_one_degree_grid  Storage for a single NED13 grid tile, plus convenient access 
IntegralLL  Integervalued, latitudestyle and longitudestyle coordinates 
Ned13_grid_cache  This caches a bunch (potentially) of onedegree grids for you 
Ned13_caching_reader  Interface to an elevationinfo object that caches its NED13 grids 
Ned13_nearest_se_neighbor_reader  Support NED 13 elevation queries by using nearest southeast neighbor 
Ned13_bilinear_reader  Support NED 13 elevation queries using bilinear interpolation 
Ned13_gp_reader  
Video_frame  
Abstract_video  
Video  
OpenSSL_EVP  Generic OpenSSL hasher class, the base class for specific derivations 
MD5  Message Digest 5 computation, using OpenSSL code 
kjb_c  
kjb_parallel  
Quaternion  
This  Sets the rotation mode of this rigid object. All euler modes are supported (XYZ, ZYZ, etc). All modes ar supported. For further details see adequately tested only in the case of mode = XYZR 
semantics  
Key_slots  
Step_code  
Categorical_event  Lookup key class for contingency table 
Categorical_event_base  Abstract base class for lookup keys 
Cell  
Marginal_cell_base  
Context_cell_base  
Prior_cell  
Marginal_cell  Concrete class for contingency table cell 
Cell_traits  
Cell_traits< T, 1 >  
Dependency_event  
Elaboration_tree  Main "Semantic tree" object 
Event_db  Database class to read and count parse tree events 
View_traits  
View_traits< S1_event >  
View_traits< S2_event >  
View_traits< U_event >  
View_traits< D1_event >  
View_traits< D2_event >  
View_traits< PCC1_event >  
View_traits< PCC2_event >  
View_traits< Hsem_event >  
View_traits< Msem_event >  
Cell_traits< semantics::D2_view, 2 >  
Event_view  Template class to represent different "views" of syntactic events 
Head_semantic_event  
Lexicon_db  
Context_cell  Class containing conditioning context for marginal cells 
Dummy_template_class  
Alpha_sampler  
Mod_semantic_event  
Nonterminal_db  
Null_semantic_event  
Punctuation_event  
Root_event  
Semantic_db  
Semantic_traits  Traits class storing information specific to given elaboration types 
Semantic_data  Concrete semantic data class for storing hash codes about nodes 
Terminal_elaboration  Class representing semantic nodes at the leaves of trees 
Nonterminal_elaboration  
Semantic_data_base  Abstract base class of Semantic Data template 
Semantic_elaboration  Base class for semantic elaborations 
Semantic_step_event  
Semantic_step_proposal  
Semantic_traits< Null_primitive >  
Semantic_traits< Unary_relation_primitive >  
Semantic_traits< Binary_relation_primitive >  
Semantic_traits< Semantic_object >  
Semantic_traits< Category_primitive >  
Semantic_traits< Color_primitive >  
Semantic_traits< Size_primitive >  
Semantic_traits< Unary_predicate >  
Semantic_traits< Binary_predicate >  
Sentence_sem  
Sem_lexer  
Semspear_tree  The main syntactic tree object for semantic parsing 
Semspear_tree_parser  
Syntactic_event  
Token_map  
TOP_event  
Tree_event  
Unary_event  
spear  
BankEdge  
CharArrayEqualFunc  
CharArrayHashFunc  
Edge  
EdgeLexer  
EdgeParser  
Exception  
HashMap  
Lexem  
Lexicon  
Model  
Pair  
Parameters  
RCObject  
RCIPtr  
StringMapEntry  
StringMap  
Tokenizer  
Trainer  
Pattern  
Tree  
Word  
std  
a  
Abstract  Abstract class to render this object 
Abstract_gibbs_step  
Abstract_hmc_step  
Abstract_mh_step  
Abstract_sampler  
All_log_recorder  
All_model_recorder  
Annealable  
Annealing_mh_step  
Annealing_proposer_wrapper  
Annealing_sampler  
base_model_archetype  
BaseModel  
Basic_gibbs_step  
Basic_hmc_step  
Basic_mh_step  
Basic_sd_step  
Best_model_recorder  
Best_target_recorder  
Blob  A simple class that represents a blob 
Blob_detector  A blob detector class. Use operator() to apply to image 
Callback_recorder  
Compute_blob  
Computes  
Conditional_distribution_proposer  
Constant_parameter_evaluator  Returns the same result no matter what model is received 
Constrained_target  Adapts a target distribution to be one with bounds 
Control_scene  Class that represents a scene plus the control ouptuts; i.e. the model for the controlpoint trajectory sampler 
Current_log_recorder  
Current_model_recorder  
Event_listener  
Expectation_recorder  
Face_data  
Features  Allows to manipulate basic 2d image features (edges, fitted line segments and manhattan worl). This is mostly useful for Manhattan world scenes so it might be renamed. This class contains the following features: 
Gaussian_random_walk_proposer  
Gaussian_scale_space  
Gaussian_scale_space_generator  
Generic_adaptive_mh_step  
Get_model_parameter  Gets the specified parameter of a model. For now, we assume all parameters are type double 
Gibbs_model_proposer  
GLUT_polymesh  
gsl_matrix  
gsl_multifit_function_fdf  
gsl_multimin_function  
gsl_multimin_function_fdf  
Gsl_rng_cmrg  Random number generator using L'Ecuyer's 1996 algorithm. This implements the Combined Multiple Recursive Generator algorithm of L'Ecuyer (1996). Period is 10 ** 56. Defined using macro Gsl_rng_template 
Gsl_rng_gfsr4  Random number generator using a fourtap XOR using a shift register. This uses Ziff's offsets (1998) and is very fast 
Gsl_rng_mrg  Random number generator using 1993 algorithm of L'Ecuyer et al. This implements the Multiple Recursive Generator algorithm of L'Ecuyer et al. (1993). Period is 10 ** 46. Defined using macro Gsl_rng_template 
Gsl_rng_mt19937  Random number generator using the "Mersenne Twister" algorithm. This implements the "Mersenne Twister" of Matsumoto and Nishimura. The period is about 10 ** 6000. This is an allaround good PRNG. Defined using macro Gsl_rng_template 
Gsl_rng_ranlxd1  Random number generator using the "RANLUX" algorithm, 48 bits, lvl. 1 This implements the "RANLUX" algorithm of Luescher at double precision. This is a "luxury random number" algorithm, i.e., slow. This one is "level 1" so it's not as decorrelated as level 2. Period is 10 ** 171. Defined using macro Gsl_rng_template 
Gsl_rng_ranlxd2  Random number generator using the "RANLUX" algorithm, 48 bits, lvl. 1 This implements the "RANLUX" algorithm of Luescher at double precision. This is a "luxury random number" algorithm, i.e., slow. This one is "level 2" so it's the most decorrelated. Period is 10 ** 171. Defined using macro Gsl_rng_template 
Gsl_rng_ranlxs0  Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. Nevertheless this one is "level 0" so it's the entrylevel luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template 
Gsl_rng_ranlxs1  Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. This one is "level 1" so it's the midlevel luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template 
Gsl_rng_ranlxs2  Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. This one is "level 2" so it's the toplevel luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template 
Gsl_rng_taus2  Random number generator using Tausworthe's algorithm. This is L'Ecuyer's version of Tausworthe's algorithm (or something like that). Period is 10 ** 26. Defined using macro Gsl_rng_template 
gsl_vector  
Independent_gaussian_proposer  
Line  
Mh_model_proposer  
Mh_proposal_result  Indicates the result of an MH proposal. It is simply a pair of probabilities, forward and backward 
Model_dimension  Returns the dimension of the model 
Model_edge  
Model_evaluator  
model_evaluator_archetype  
Model_parameter_evaluator  
model_proposer_archetype  
Model_recorder  
model_recorder_archetype  
ModelEvaluator  
ModelProposer  
ModelRecorder  
Modulo_recorder  
Move_model_parameter  Moves the specified parameter of a model. For now, we assume all parameters are type double 
Move_model_parameter_as_plus  Default move function; uses '+' 
Multi_model_recorder  
Multi_proposer_proposer  
Multi_step_sampler  
null_deleter  
Mv_gaussian_proposer  
Null_event_listener  
Null_recorder  
Null_value  
Numerical_gradient  Approximates the gradient and/or curvature of a target distribution, evaluated at a certain location. The user must provide the mechanisms to change the model (see constructor) 
Ostream_recorder  
Posterior  Generic posterior class 
Real_hmc_step  
Real_numerical_gradient  Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model 
Real_sd_step  
Recent_log_recorder  
Recent_model_recorder  
Sampler_step  
Serialize_recorder  
Set_model_parameter  Sets the specified parameter of a model. For now, we assume all parameters are type double 
Simple_adaptive_mh_step  
Single_dimension_proposer  
Single_step_sampler  
ST_SPHERE  
Step_log  
Step_result  Structure for returning results of a single sampling move 
triangulateio  
Updatable  
Vector_hmc_step  
vector_model_archetype  
Vector_numerical_gradient  Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model 
Vector_sd_step  
Vector_srw_step  
VectorModel  
Viewing_recorder  