hippo
index
/builddir/build/BUILD/HippoDraw-1.21.1/python/.libs/hippomodule.so

 
Classes
       
Boost.Python.enum(__builtin__.int)
ColorValue
Line
Symbol
Boost.Python.instance(__builtin__.object)
Canvas
CanvasWindow
CutController
DataArray
DataRep
DataSource
FitsNTuple
ListTuple
NTupleInternal
CircularBuffer
NTuple
NumArrayTuple
Display
Cut
FCNBase
StatedFCN
NTupleFCN
FactoryPointRep
PointRepFactory
FitsController
Fitter
FitterFactory
Function
FunctionBase
FunctionFactory
HDApp
NTupleController
Observable
Observer
RepBase

 
class Canvas(Boost.Python.instance)
    The HippoDraw canvas.
 
This class provides an interface to the canvas.
One can take various actions that are also
available from menu items in the canvas window.
 
 
Method resolution order:
Canvas
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
__reduce__ = (...)
addDisplay(...)
addDisplay( (Canvas)arg1, (Display)arg2) -> None :
    addDisplay ( Display ) -> None
    
    Adds a display to the canvas.
 
    C++ signature :
        void addDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
addText(...)
addText( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
    addText ( Display, string ) -> None
    
    Adds text to display.
 
    C++ signature :
        void addText(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
addTextAt(...)
addTextAt( (Canvas)arg1, (Display)arg2, (str)arg3, (float)arg4, (float)arg5) -> None :
    addTextAt ( Display, string, value, value ) -> None
    
    Adds text to a display at specified position
    Position is fraction of width and height.
 
    C++ signature :
        void addTextAt(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string,double,double)
addTextAtAbs(...)
addTextAtAbs( (Canvas)arg1, (Display)arg2, (str)arg3, (float)arg4, (float)arg5) -> None :
    addTextAt ( Display, string, value, value ) -> None
    
    Adds text to a display at specified position
    Position is absolute value of the date point.
 
    C++ signature :
        void addTextAtAbs(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string,double,double)
addTextRep(...)
addTextRep( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
    addTextRep ( Display, string ) -> None
    
    Adds textual data representation to display.  Use
    Canvas.getTextRepTypes() to see available types.
 
    C++ signature :
        void addTextRep(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
clear(...)
clear( (Canvas)arg1) -> None :
    clear () -> None
    
    Removes all items from the canvas
 
    C++ signature :
        void clear(hippodraw::PyCanvas {lvalue})
close(...)
close( (Canvas)arg1) -> None :
    close () -> None
    
    Closes the window.
 
    C++ signature :
        void close(hippodraw::PyCanvas {lvalue})
getCut(...)
getCut( (Canvas)arg1) -> Cut :
    getCut () -> Cut
    
    Returns the currently selected Cut object.
 
    C++ signature :
        hippodraw::QtCut* getCut(hippodraw::PyCanvas {lvalue})
getDisplay(...)
getDisplay( (Canvas)arg1) -> Display :
    getDisplay () -> Display
    
    Returns the selected Display object.
 
    C++ signature :
        hippodraw::QtDisplay* getDisplay(hippodraw::PyCanvas {lvalue})
getDisplays(...)
getDisplays( (Canvas)arg1) -> object :
    getDisplays () -> tuple
    
    Returns a tuple of all Display objects on the canvas.
 
    C++ signature :
        std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> > getDisplays(hippodraw::PyCanvas {lvalue})
getHeight(...)
getHeight( (Canvas)arg1, (Display)arg2) -> int :
    getHeight ( Display ) -> value
    
    Returns the height of the Display.
 
    C++ signature :
        int getHeight(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
getPickTable(...)
getPickTable( (Canvas)arg1, (Display)arg2) -> NTupleInternal :
    getPickTable ( Display ) -> NTuple
    
    Gets the pick table of the Display.
 
    C++ signature :
        hippodraw::NTuplegetPickTable(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
getSelPickTable(...)
getSelPickTable( (Canvas)arg1) -> NTupleInternal :
    getSelPickTable () -> NTuple
    
    Gets the pick table for selected Display.
 
    C++ signature :
        hippodraw::NTuplegetSelPickTable(hippodraw::PyCanvas {lvalue})
getTextRepTypes(...)
getTextRepTypes( (Canvas)arg1) -> object :
    getTextRepTypes () -> tuple
    
    Returns the types of textual data representations available.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getTextRepTypes(hippodraw::PyCanvas {lvalue})
getWidth(...)
getWidth( (Canvas)arg1, (Display)arg2) -> int :
    getWidth ( Display ) -> value
    
    Returns the width of the Display.
 
    C++ signature :
        int getWidth(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
getX(...)
getX( (Canvas)arg1, (Display)arg2) -> int :
    getX ( Display ) -> value
    
    Returns the X coordinate of the Display.
 
    C++ signature :
        int getX(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
getY(...)
getY( (Canvas)arg1, (Display)arg2) -> int :
    getY ( Display ) -> value
    
    Returns the Y coordinate of the Display.  Note that Y=0 is
    at the top and Y increases downward.
 
    C++ signature :
        int getY(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
mouseData(...)
mouseData( (Canvas)arg1) -> object :
    mouseData () -> tuple
    
    Returns a tuple of picked data.
 
    C++ signature :
        std::vector<double, std::allocator<double> > mouseData(hippodraw::PyCanvas {lvalue})
printTo(...)
printTo( (Canvas)arg1, (str)arg2) -> None :
    printTo ( string ) -> None
    
    Prints the canvas to PostScript file.
 
    C++ signature :
        void printTo(hippodraw::PyCanvas {lvalue},std::string)
removeDisplay(...)
removeDisplay( (Canvas)arg1, (Display)arg2) -> None :
    removeDisplay ( Display ) -> None
    
    Removes the display from the canvas.
 
    C++ signature :
        void removeDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
saveAs(...)
saveAs( (Canvas)arg1, (str)arg2) -> None :
    saveAs ( string ) -> None
    
    Save the canvas as a XML file.
 
    C++ signature :
        void saveAs(hippodraw::PyCanvas {lvalue},std::string)
saveAsImage(...)
saveAsImage( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
    saveAsImage ( Display, string ) -> None
    
    Save a display as an image file.
    The suffix of the file name controls the image type.
 
    C++ signature :
        void saveAsImage(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
saveSelectedImages(...)
saveSelectedImages( (Canvas)arg1, (str)arg2) -> None :
    saveSelectedImages ( string ) -> None
    
    Save the selected displays as an image file.
    The suffix of the file name controls the image type.
 
    C++ signature :
        void saveSelectedImages(hippodraw::PyCanvas {lvalue},std::string)
selectAllDisplays(...)
selectAllDisplays( (Canvas)arg1, (bool)arg2) -> None :
    selectAllDisplays ( Boolean ) -> None
    
    Sets all displays to selected state or not.
 
    C++ signature :
        void selectAllDisplays(hippodraw::PyCanvas {lvalue},bool)
selectDisplay(...)
selectDisplay( (Canvas)arg1, (Display)arg2) -> None :
    selectDisplay ( Display ) -> None
    
    Sets a display to selected state.
 
    C++ signature :
        void selectDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
setHeight(...)
setHeight( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
    setHeight ( Display, value ) -> None
    
    Sets the height of the Display.
 
    C++ signature :
        void setHeight(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
setPlotMatrix(...)
setPlotMatrix( (Canvas)arg1, (int)arg2, (int)arg3) -> None :
    setPlotMatrix ( columns, rows ) -> None
    
    Sets the number of columns and rows of plots for each page.
 
    C++ signature :
        void setPlotMatrix(hippodraw::PyCanvas {lvalue},unsigned int,unsigned int)
setWidth(...)
setWidth( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
    setWidth ( Display, value ) -> None
    
    Sets the width of the Display.
 
    C++ signature :
        void setWidth(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
setX(...)
setX( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
    setX ( Display, value ) -> None
    
    Sets the X coordinate of the Display
 
    C++ signature :
        void setX(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
setY(...)
setY( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
    setY ( Display, value ) -> None
    
    Sets the Y coordinate of the Display.   Note that Y = 0 is
    at the top and Y increases downward.
 
    C++ signature :
        void setY(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
show(...)
show( (Canvas)arg1) -> None :
    show () -> None
    
    Displays the canvas window on the screen.   One only needs
    to use this method if running HippoDraw in the Python
    thread.
 
    C++ signature :
        void show(hippodraw::PyCanvas {lvalue})
swapOrientation(...)
swapOrientation( (Canvas)arg1) -> None :
    swapOrientation ( ) -> None
    
    Swaps the canvas' orientation from portrait to landscape
    or vice verse.
 
    C++ signature :
        void swapOrientation(hippodraw::PyCanvas {lvalue})

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class CanvasWindow(Boost.Python.instance)
    The CanvasWindow class contains the Canvas and some controls via
menu items and dialogs.
 
 
Method resolution order:
CanvasWindow
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
fileNew(...)
fileNew( (CanvasWindow)arg1) -> None :
    fileNew ( None ) -> None
    
    Creates a new CanvasWindow.
 
    C++ signature :
        void fileNew(hippodraw::CanvasWindow {lvalue})
show(...)
show( (CanvasWindow)arg1) -> None :
    show ( None ) -> None
    
    Brings the canvas window onto the screen.
 
    C++ signature :
        void show(hippodraw::CanvasWindow {lvalue})

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class CircularBuffer(NTupleInternal)
    A circular buffer in a NTuple that adds rows up to a defined number,
then starts replacing the oldest rows.
 
 
Method resolution order:
CircularBuffer
NTupleInternal
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
    CircularBuffer ( None ) -> CircularBuffer
    CircularBuffer ( value ) -> CircularBuffer
    CircularBuffer ( string ) -> CircularBuffer
    CircularBuffer ( sequence ) -> CircularBuffer 
    CircularBuffer ( CircularBuffer ) -> CircularBuffer
    
    There are five forms of construction of a CircularBuffer.   The
    first form creates an empty one.   The second from creates an empty
    one with `value' number of columns.   The third from creates an
    empty one the number of columns equal to the size of the sequence.
    The column labels are taken from the sequence.   The final form is
    the copy constructor.
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,int)
 
__init__( (object)arg1, (str)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,std::string)
 
__init__( (object)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (CircularBuffer)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::CircularBuffer)
__reduce__ = (...)
addRow(...)
addRow( (CircularBuffer)arg1, (object)arg2) -> None :
    addRow ( sequence ) -> None
    
    Append a row at the end of the table until it is full,
    then replace the oldest row.
 
    C++ signature :
        void addRow(hippodraw::CircularBuffer {lvalue},std::vector<double, std::allocator<double> >)
clear(...)
clear( (CircularBuffer)arg1) -> None :
    clear ( None ) -> None
    
    Clears the contents of the buffer
 
    C++ signature :
        void clear(hippodraw::CircularBuffer {lvalue})
reserve(...)
reserve( (CircularBuffer)arg1, (int)arg2) -> None :
    reserve ( value ) -> None
    
    Sets the maximum size of the buffer
 
    C++ signature :
        void reserve(hippodraw::CircularBuffer {lvalue},unsigned int)

Data descriptors defined here:
columns
rows

Data and other attributes defined here:
__instance_size__ = 128

Methods inherited from NTupleInternal:
getLabel(...)
getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
    getLabel ( index ) -> string
    
    Returns the label at column index.
 
    C++ signature :
        std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
getRow(...)
getRow( (NTupleInternal)arg1, (int)arg2) -> object :
    getRow ( index ) -> list
    
    Returns the index row as list floats.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
setIntervalCount(...)
setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
    setIntervalCount ( count ) -> None
    
    Sets the interval count between updates to the observers.
 
    C++ signature :
        void setIntervalCount(hippodraw::NTuple {lvalue},int)
setIntervalEnabled(...)
setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
    setIntervalEnable ( Boolean ) -> None
    
    Sets the interval counting on or off
 
    C++ signature :
        void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
setLabels(...)
setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
    setLabels ( sequence ) -> None
    
    Sets the labels of the columns from the list of strings.  If the
    NTuple is empty, then also sets the number of columns to be the
    size of the list.   If the number of columns has already been
    set, the the size of the list should be the same, otherwise
    a RuntimeError exception is thrown.
 
    C++ signature :
        void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)

Methods inherited from DataSource:
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
replaceColumn(...)
replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( label, list ) -> None
    
    Replaces the column of data by abel.
 
    C++ signature :
        void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class ColorValue(Boost.Python.enum)
    
Method resolution order:
ColorValue
Boost.Python.enum
__builtin__.int
__builtin__.object

Data and other attributes defined here:
black = hippo.ColorValue.black
blue = hippo.ColorValue.blue
cyan = hippo.ColorValue.cyan
darkgray = hippo.ColorValue.darkgray
green = hippo.ColorValue.green
lightgray = hippo.ColorValue.lightgray
magenta = hippo.ColorValue.magenta
orange = hippo.ColorValue.orange
red = hippo.ColorValue.red
values = {0: hippo.ColorValue.red, 1: hippo.ColorValue.green, 2: hippo.ColorValue.blue, 3: hippo.ColorValue.yellow, 4: hippo.ColorValue.orange, 5: hippo.ColorValue.cyan, 6: hippo.ColorValue.magenta, 7: hippo.ColorValue.black, 8: hippo.ColorValue.darkgray, 9: hippo.ColorValue.lightgray, ...}
white = hippo.ColorValue.white
yellow = hippo.ColorValue.yellow

Methods inherited from Boost.Python.enum:
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data descriptors inherited from Boost.Python.enum:
name

Methods inherited from __builtin__.int:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__trunc__(...)
Truncating an Integral returns itself.
__xor__(...)
x.__xor__(y) <==> x^y
conjugate(...)
Returns self, the complex conjugate of any int.

Data descriptors inherited from __builtin__.int:
denominator
the denominator of a rational number in lowest terms
imag
the imaginary part of a complex number
numerator
the numerator of a rational number in lowest terms
real
the real part of a complex number

Data and other attributes inherited from __builtin__.int:
__new__ = <built-in method __new__ of type object at 0xf7f5d8e0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Cut(Display)
    An object of this class applies a cut or filter on the data that is
used as input to its target displays.
 
 
Method resolution order:
Cut
Display
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1, (DataSource)arg2, (object)arg3) -> None :
    Cut ( DataSource, sequence ) -> Cut
    Cut ( DataArray, sequence ) -> Cut
    Cut ( DataSource, sequence, Display, value, value ) -> Cut
    Cut ( DataArray, sequence, Display, value, value ) -> Cut
    
    Creates a Cut bound to DataSource.  For each form, the first
    argument is the DataSource and the second argument is sequence of
    strings specifying the binding.  The latter two forms apply the
    Cut to a Display with low and high values for the Cut range.
 
    C++ signature :
        void __init__(_object*,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (DataSource)arg2, (object)arg3, (Display)arg4, (float)arg5, (float)arg6) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >,hippodraw::QtDisplay*,double,double)
 
__init__( (object)arg1, (DataArray)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (DataArray)arg2, (object)arg3, (Display)arg4, (float)arg5, (float)arg6) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >,hippodraw::QtDisplay*,double,double)
 
__init__( (object)arg1, (DataArray)arg2, (str)arg3, (object)arg4, (Display)arg5) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array,hippodraw::QtDisplay*)
__reduce__ = (...)
addTarget(...)
addTarget( (Cut)arg1, (Display)arg2) -> None :
    addTarget ( Display ) -> None
    
    Adds a Display to the list of targets.
 
    C++ signature :
        void addTarget(hippodraw::QtCut {lvalue},hippodraw::QtDisplay*)
addTargets(...)
addTargets( (Cut)arg1, (object)arg2) -> None :
    addTargets ( sequence ) -> None
    
    Adds Display objects in the sequence to the list targets
 
    C++ signature :
        void addTargets(hippodraw::QtCut {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
cutRange(...)
cutRange( (Cut)arg1) -> object :
    cutRange () -> tuple
    
    Returns a pair of values of the range of each Cut.
 
    C++ signature :
        std::vector<double, std::allocator<double> > cutRange(hippodraw::QtCut {lvalue})
setCutRange(...)
setCutRange( (Cut)arg1, (float)arg2, (float)arg3, (str)arg4) -> None :
    setCutRange ( value, value, string ) -> None
    
    Sets the range of the Cut.  Arguments are low and high values,
    and the axis.
 
    C++ signature :
        void setCutRange(hippodraw::QtCut {lvalue},double,double,std::string)
setEnabled(...)
setEnabled( (Cut)arg1, (bool)arg2) -> None :
    setEnabled ( Boolean ) -> None
    
    Sets the cut to be enabled or not
 
    C++ signature :
        void setEnabled(hippodraw::QtCut {lvalue},bool)
toggleInverted(...)
toggleInverted( (Cut)arg1) -> None :
    toggleInverted () -> None
    
    Toggles the inversion status
 
    C++ signature :
        void toggleInverted(hippodraw::QtCut {lvalue})

Static methods defined here:
createFits(...)
createFits( (object)arg1, (object)arg2, (DataSource)arg3, (str)arg4, (str)arg5) -> None :
    createFits ( sequence, sequence, DataSource, string, string )->None
    
    Create a new FITS file using cut list and column list.
    This method is deprecated, use the FitsController instead.
 
    C++ signature :
        void createFits(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*,std::string,std::string)
createNTuple(...)
createNTuple( (object)arg1, (object)arg2, (DataSource)arg3) -> NTupleInternal :
    createNTuple ( sequence, sequence, DataSource ) -> NTuple
    
    Create a new NTuple using cut list and column list.
 
    C++ signature :
        hippodraw::NTuplecreateNTuple(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*)
createTnt(...)
createTnt( (object)arg1, (object)arg2, (DataSource)arg3, (str)arg4, (str)arg5) -> None :
    createTnt ( sequence, sequence, DataSource, string, string )-> None
    
    Create a new TNT file using cut list and column list.
 
    C++ signature :
        void createTnt(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*,std::string,std::string)

Data and other attributes defined here:
__instance_size__ = 72

Methods inherited from Display:
addDataRep(...)
addDataRep( (Display)arg1, (DataRep)arg2) -> None :
    addDataRep ( DataRep ) -> Display
    addDataRep ( Function ) -> Display
    addDataRep ( string, DataSource, tuple ) -> Display
    
    Adds a DataRep to the display sharing the same Y axis range
    The first two methods adds existing DataRep or Function to the
    Display.  The third method creates and adds DataRep to the
    Display.  Arguments are same as Display constructor.
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyDataRep*)
 
addDataRep( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
 
addDataRep( (Display)arg1, (Function)arg2) -> None :
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyFunctionRep*)
addDataRepStacked(...)
addDataRepStacked( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
    addDataRepStacked ( string, DataSource, tuple ) -> Display
    
    Creates and adds a DataRep with independent Y axis ranges.
    The arguments are the same as Display constructor.
 
    C++ signature :
        void addDataRepStacked(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
addFunction(...)
addFunction( (Display)arg1, (FunctionBase)arg2) -> None :
    addFunction ( FunctionBase ) -> None
    
    Adds a FunctionBase object to the display by appropriately
    wrapping it with a Function.
 
    C++ signature :
        void addFunction(hippodraw::QtDisplay {lvalue},hippodraw::FunctionBase*)
addObserver(...)
addObserver( (Display)arg1, (Observer)arg2) -> None :
    addObserver ( Observer ) -> None
    
    Adds an Observer to the Display object.
 
    C++ signature :
        void addObserver(hippodraw::QtDisplay {lvalue},hippodraw::Observer*)
addValues(...)
addValues( (Display)arg1, (object)arg2) -> None :
    addValue ( tuple ) -> None
    
    For static histograms, adds a value to the accumulation.
    For 1D histogram, the tuple should contain one or two values,
    the second used as a weight.  For 2D histogram, the tuple should
    contain two or three elements, the third being the weight.
    non static Displays do nothing.
 
    C++ signature :
        void addValues(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
applyCut(...)
applyCut( (Display)arg1, (Display)arg2) -> None :
    applyCut ( Cut ) -> None
    
    Apply a Cut to the Display
 
    C++ signature :
        void applyCut(hippodraw::QtDisplay {lvalue},hippodraw::QtDisplay*)
applyCuts(...)
applyCuts( (Display)arg1, (object)arg2) -> None :
    applyCuts ( sequence ) -> None
    
    Apply each Cut in the sequence to the Display
 
    C++ signature :
        void applyCuts(hippodraw::QtDisplay {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
createDataArray(...)
createDataArray( (Display)arg1) -> DataArray :
    createDataArray ( ) -> DataArray
    
    Returns a DataArray representation of the Display's contents
    (This method available if configured with numarray)
 
    C++ signature :
        hippodraw::PyDataSource* createDataArray(hippodraw::QtDisplay {lvalue})
currentView(...)
currentView( (Display)arg1) -> int :
    currentView ( ) -> int
    
    Index of the current view.
 
    C++ signature :
        int currentView(hippodraw::QtDisplay {lvalue})
deleteView(...)
deleteView( (Display)arg1, (int)arg2) -> None :
    deleteView ( int ) -> None
    
    Delete a view by index.
 
    C++ signature :
        void deleteView(hippodraw::QtDisplay {lvalue},int)
getBinWidth(...)
getBinWidth( (Display)arg1, (str)arg2) -> float :
    getBinWidth ( string ) -> value
    
    Returns the bin width on axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        double getBinWidth(hippodraw::QtDisplay {lvalue},std::string)
getDataRep(...)
getDataRep( (Display)arg1) -> DataRep :
    getDataRep ( ) -> DataRep
    
    Returns a reference to the active DataRep or if all DataRep objects are
    active, returns a reference to the first one.
 
    C++ signature :
        hippodraw::PyDataRep* getDataRep(hippodraw::QtDisplay {lvalue})
getDataReps(...)
getDataReps( (Display)arg1) -> object :
    getDataReps ( ) -> list
    
    Returns a list of DataRep objects contained by the Display..
 
    C++ signature :
        std::vector<hippodraw::PyDataRep*, std::allocator<hippodraw::PyDataRep*> > getDataReps(hippodraw::QtDisplay {lvalue})
getLabel(...)
getLabel( (Display)arg1, (str)arg2) -> str :
    getLabel ( string ) -> string
    
    Returns the label of the axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        std::string getLabel(hippodraw::QtDisplay {lvalue},std::string)
getLog(...)
getLog( (Display)arg1, (str)arg2) -> int :
    getLog ( string ) -> value
    
    Returns True if axis specified as a string, e.g. 'x', is being
    displayed on a logarithmic scale.
 
    C++ signature :
        int getLog(hippodraw::QtDisplay {lvalue},std::string)
getRange(...)
getRange( (Display)arg1, (str)arg2) -> object :
    getRange ( string ) -> tuple
    
    Returns the tuple representing the range for the axis specified
    as a string, e.g., 'x'.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getRange(hippodraw::QtDisplay {lvalue},std::string)
getTitle(...)
getTitle( (Display)arg1) -> str :
    getTitle () -> string
    
    Returns the current title.   The title will be the title of
    the DataSource unless it has been explicitly changed.
 
    C++ signature :
        std::string getTitle(hippodraw::QtDisplay {lvalue})
nextView(...)
nextView( (Display)arg1, (bool)arg2) -> int :
    nextView ( bool ) -> int
    
    Cycle to the next view in the view buffer. Set the argument to True to cycle for wards, False to cycle back wards.
    Returns the index of the new view.
 
    C++ signature :
        int nextView(hippodraw::QtDisplay {lvalue},bool)
numViews(...)
numViews( (Display)arg1) -> int :
    numViews ( ) -> int
    
    Return the number of stored views.
 
    C++ signature :
        int numViews(hippodraw::QtDisplay {lvalue})
numberOfEntries(...)
numberOfEntries( (Display)arg1) -> float :
    numberOfEntries ( ) -> value
    
    Returns the number of entries in the Display.
 
    C++ signature :
        double numberOfEntries(hippodraw::QtDisplay {lvalue})
plotterId(...)
plotterId( (Display)arg1) -> int :
    plotterId () -> value
    
    Returns a unique identifier for the Display.
 
    C++ signature :
        int plotterId(hippodraw::QtDisplay {lvalue})
reset(...)
reset( (Display)arg1) -> None :
    reset () -> None
    
    Resets the contents of all bins.   Only applicable to static
    histograms.
 
    C++ signature :
        void reset(hippodraw::QtDisplay {lvalue})
resize(...)
resize( (Display)arg1) -> None :
    resize () -> None
    
    Resizes the Display to its saved values.
 
    C++ signature :
        void resize(hippodraw::QtDisplay {lvalue})
saveView(...)
saveView( (Display)arg1) -> int :
    saveView ( ) -> int
    
    Saves the current set of x and y ranges and returns the index of the saved view.
 
    C++ signature :
        int saveView(hippodraw::QtDisplay {lvalue})
setAspectRatio(...)
setAspectRatio( (Display)arg1, (float)arg2) -> None :
    setAspectRatio ( value ) -> None
    
    Sets the required aspect ratio of the Display to value, the
    ratio of the width to the height.
 
    C++ signature :
        void setAspectRatio(hippodraw::QtDisplay {lvalue},double)
setAutoRanging(...)
setAutoRanging( (Display)arg1, (str)arg2, (bool)arg3) -> None :
    setAutoRanging ( string, Boolean ) -> None
    
    Sets auto-ranging on axis specified as a string, e.g. 'x',non or off.
 
    C++ signature :
        void setAutoRanging(hippodraw::QtDisplay {lvalue},std::string,bool)
setAutoTicks(...)
setAutoTicks( (Display)arg1, (str)arg2, (bool)arg3) -> None :
    setAutoTicks ( Boolean ) -> None
    
    Set the ticks generation to be automatic (the default) or
    manually.
 
    C++ signature :
        void setAutoTicks(hippodraw::QtDisplay {lvalue},std::string,bool)
setBinWidth(...)
setBinWidth( (Display)arg1, (str)arg2, (float)arg3, (bool)arg4) -> None :
    Set the bin width, explicitly saving the value or not.
 
    C++ signature :
        void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double,bool)
 
setBinWidth( (Display)arg1, (str)arg2, (float)arg3) -> None :
    setBinWidth ( string, value ) -> None
    
    Set the bin width to value  on axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double)
setColorMap(...)
setColorMap( (Display)arg1, (str)arg2) -> None :
    setColorMap ( string ) -> None
    
    Set the value-to-color map to one named by the argument.
 
    C++ signature :
        void setColorMap(hippodraw::QtDisplay {lvalue},std::string)
setContourLevels(...)
setContourLevels( (Display)arg1, (object)arg2) -> None :
    setContourLevels ( sequence ) -> None
    
    Sets the contour levels if the Display is using contour point
    representation from the values in the sequence.
 
    C++ signature :
        void setContourLevels(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
setLabel(...)
setLabel( (Display)arg1, (str)arg2, (str)arg3) -> None :
    setLabel ( string, string ) -> None
    
    Sets the label for the axis specified by first argument to value
    of the second argument.
 
    C++ signature :
        void setLabel(hippodraw::QtDisplay {lvalue},std::string,std::string)
setLog(...)
setLog( (Display)arg1, (str)arg2, (int)arg3) -> None :
    setLog ( string, Boolean ) -> None
    
    Sets the axis specified by the first argument on log scale.
 
    C++ signature :
        void setLog(hippodraw::QtDisplay {lvalue},std::string,int)
setNumberOfBins(...)
setNumberOfBins( (Display)arg1, (str)arg2, (int)arg3) -> None :
    setNumberOfBins ( string, value ) -> None
    
    Sets the number of bins on named axis, e.g. 'x' to the given 
    value.
 
    C++ signature :
        void setNumberOfBins(hippodraw::QtDisplay {lvalue},std::string,unsigned int)
setOffset(...)
setOffset( (Display)arg1, (str)arg2, (float)arg3) -> None :
    setOffset ( string, value ) -> None
    
    Sets the offset of the bins relative to their current width on
    specified axis.
 
    C++ signature :
        void setOffset(hippodraw::QtDisplay {lvalue},std::string,double)
setPointRep(...)
setPointRep( (Display)arg1, (RepBase)arg2) -> None :
    setPointRep ( RepBase ) -> None
    
    Sets the point representation to be used.
 
    C++ signature :
        void setPointRep(hippodraw::QtDisplay {lvalue},hippodraw::RepBase*)
setRange(...)
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
 
    C++ signature :
        void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double)
 
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4, (bool)arg5) -> None :
    setRange ( string, value, value ) -> None
    setRange ( string, value, value, Boolean ) -> None
    
    Set the upper and lower bounds for the specified axis.  For the
    second form, also save them if the Boolean argument is true.
 
    C++ signature :
        void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double,bool)
setTicks(...)
setTicks( (Display)arg1, (str)arg2, (object)arg3, (object)arg4) -> None :
    setTicks ( string, sequence, sequence ) -> None
    
    Sets the tick locations and labels.   The first argument is the
     axis, the second argument is a sequence containing the
    locations, and the third argument is a sequence of tick labels.
 
    C++ signature :
        void setTicks(hippodraw::QtDisplay {lvalue},std::string,std::vector<double, std::allocator<double> >,std::vector<std::string, std::allocator<std::string> >)
setTitle(...)
setTitle( (Display)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the display.
 
    C++ signature :
        void setTitle(hippodraw::QtDisplay {lvalue},std::string)
setTransform(...)
setTransform( (Display)arg1, (str)arg2) -> None :
    setTransform ( string ) -> None
    
    Sets the transform object.
 
    C++ signature :
        void setTransform(hippodraw::QtDisplay {lvalue},std::string)
setView(...)
setView( (Display)arg1, (int)arg2) -> None :
    setView ( int ) -> None
    
    Set the view by its index.
 
    C++ signature :
        void setView(hippodraw::QtDisplay {lvalue},int)
unlock(...)
unlock( (Display)arg1) -> None :
    unlock () -> None
    
    Unlock the application thread.
 
    C++ signature :
        void unlock(hippodraw::QtDisplay {lvalue})
update(...)
update( (Display)arg1) -> None :
    update () -> None
    
    Updates the display.
 
    C++ signature :
        void update(hippodraw::QtDisplay {lvalue})

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class CutController(Boost.Python.instance)
    The CutController class provides interface to Cut functions.
 
 
Method resolution order:
CutController
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
createIdCut(...)
createIdCut( (CutController)arg1, (DataSource)arg2, (DataSource)arg3) -> None :
    createIdCut (source, dest ) -> None
    
    Creates a column in dest that can be used as Cut on it, 
    for values in source
 
    C++ signature :
        void createIdCut(hippodraw::CutController {lvalue},hippodraw::DataSource const*,hippodraw::DataSource*)

Static methods defined here:
instance(...)
instance() -> CutController :
    instance () -> CutController
    
    Returns the singleton instance of the controller.
 
    C++ signature :
        hippodraw::CutControllerinstance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class DataArray(Boost.Python.instance)
    DataArray wraps a DataSource object so that numerical Python
arrays can be used as both input and output.   The numerical array
can be either a numarray.array or Numeric.array depending on
how the hippo module was configured.
 
Access to the array is done like a Python list or dictionary.
        array = my_data_array [ index ] # list form
        array = my_data_array [ 'my_label' ] # dict form
 
Storage to the array is also done like a Python list or dictionary.
        my_data_array [ index ] = ... # list form
        my_data_array [ 'my_label' ] = ... # dict form
 
 
Method resolution order:
DataArray
Boost.Python.instance
__builtin__.object

Methods defined here:
__getitem__(...)
__getitem__( (DataArray)arg1, (str)arg2) -> NDArray :
    __getitem__ ( value ) -> array
    
    Returns a copy of the column as numerical array.   'value' can
    be either the column label or its index.
 
    C++ signature :
        boost::python::numeric::array __getitem__(hippodraw::PyDataSource {lvalue},std::string)
 
__getitem__( (DataArray)arg1, (int)arg2) -> NDArray :
 
    C++ signature :
        boost::python::numeric::array __getitem__(hippodraw::PyDataSource {lvalue},unsigned int)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (str)arg2) -> None :
    DataArray ( string ) -> DataArray
    
    Creates a DataArray.   The string can be one of
        ListTuple
        NTuple
        NumArrayTuple
 
    C++ signature :
        void __init__(_object*,std::string)
__reduce__ = (...)
__setitem__(...)
__setitem__( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
    __setitem__ ( label, sequence ) -> None
    
    Copies the contensts of the sequence.   If column with label
    already exists, replaces it, otherwise add a new column.
 
    C++ signature :
        void __setitem__(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
 
__setitem__( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
    __setitem__ ( value, array ) -> None
    
    Copies the contents of array.  If `'value' is an index, then
    replaces the contents of the existing column.   If 'value' is
    a label then either replaces existing column with that label
    or adds a new column.
 
    C++ signature :
        void __setitem__(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
 
__setitem__( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __setitem__(hippodraw::PyDataSource {lvalue},unsigned int,boost::python::numeric::array)
addColumn(...)
addColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> int :
    addColumn ( string, list ) -> value
    addColumn ( string, array ) -> value
    
    Adds a column. The string will be the label of the column.
    A copy of the list or array values will be the contents.
    The second form is only available if HippoDraw was configured
    with numerical Python support. Returns the new column's index.
 
    C++ signature :
        int addColumn(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
 
addColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> int :
 
    C++ signature :
        int addColumn(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
addRow(...)
addRow( (DataArray)arg1, (object)arg2) -> None :
    addRow ( sequence ) -> None
    
    Adds a row to the held DataSource object if supported, otherwise throws Runtime exception.
 
    C++ signature :
        void addRow(hippodraw::PyDataSource {lvalue},std::vector<double, std::allocator<double> >)
append(...)
append( (DataArray)arg1, (DataSource)arg2) -> None :
    append ( DataArray ) -> None
    append ( DataSource ) -> None
    
    Appends contents of DataSource or DataArray to the DataArray.
 
    C++ signature :
        void append(hippodraw::PyDataSource {lvalue},hippodraw::DataSource const*)
 
append( (DataArray)arg1, (DataArray)arg2) -> None :
 
    C++ signature :
        void append(hippodraw::PyDataSource {lvalue},hippodraw::PyDataSource const*)
dataSource(...)
dataSource( (DataArray)arg1) -> DataSource :
    dataSource () -> DataSource
    
    Returns reference to underlying DataSource
 
    C++ signature :
        hippodraw::DataSource dataSource(hippodraw::PyDataSource {lvalue})
getColumn(...)
getColumn( (DataArray)arg1, (int)arg2) -> object :
    getColumn ( value ) -> list
    
    Returns a column as list of floats.  'value' maybe either
    the column label or its index.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::PyDataSource {lvalue},unsigned int)
 
getColumn( (DataArray)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::PyDataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataArray)arg1) -> object :
    getLabels () -> list
    
    Returns the list of string objects of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::PyDataSource {lvalue})
getTitle(...)
getTitle( (DataArray)arg1) -> str :
    getTitle () -> string
    
    Returns title of the DataSource.
 
    C++ signature :
        std::string getTitle(hippodraw::PyDataSource {lvalue})
has_key(...)
has_key( (DataArray)arg1, (str)arg2) -> bool :
    has_key ( string ) -> Boolean
    
    Returns True if column with label exists.
 
    C++ signature :
        bool has_key(hippodraw::PyDataSource {lvalue},std::string)
keys(...)
keys( (DataArray)arg1) -> object :
    keys () -> list
    
    Returns the list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > keys(hippodraw::PyDataSource {lvalue})
register(...)
register( (DataArray)arg1, (str)arg2) -> None :
    register ( string ) -> None
    register ( ) -> string
    
    Register the underlying DataSource with the
    DataSourceController. The first form registers it with the
    given name, while the second from returns a unique name
    generated by the controller.
 
    C++ signature :
        void register(hippodraw::PyDataSource {lvalue},std::string)
 
register( (DataArray)arg1) -> str :
 
    C++ signature :
        std::string register(hippodraw::PyDataSource {lvalue})
replaceColumn(...)
replaceColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( value, list ) -> None
    replaceColumn ( value, array ) -> None
    
    Replace column by its label or index.  The second form is 
    only available if HippoDraw was configure with numerical
    arrays.
 
    C++ signature :
        void replaceColumn(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
 
replaceColumn( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
 
    C++ signature :
        void replaceColumn(hippodraw::PyDataSource {lvalue},unsigned int,std::vector<double, std::allocator<double> >)
 
replaceColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
 
    C++ signature :
        void replaceColumn(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
 
replaceColumn( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
 
    C++ signature :
        void replaceColumn(hippodraw::PyDataSource {lvalue},unsigned int,boost::python::numeric::array)
setName(...)
setName( (DataArray)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the DataSource. The name should be unique
    with one application and may appear in the Inspector panel.
 
    C++ signature :
        void setName(hippodraw::PyDataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataArray)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the DataSource.  The title is what appears,
    by default, at the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::PyDataSource {lvalue},std::string)

Static methods defined here:
getCurrent(...)
getCurrent() -> DataArray :
    getCurrent () -> DataArray
    
    Returns a DataArray that wraps the current DataSource.
 
    C++ signature :
        hippodraw::PyDataSource* getCurrent()

Data descriptors defined here:
columns
rows

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class DataRep(Boost.Python.instance)
    A base class for representing data in various ways.   For example, a
a histogram is a way to represent a column of data.
 
 
Method resolution order:
DataRep
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
    DataRep ( string ) -> DataRep
    DataRep ( string, DataSource, sequence ) -> DataRep
    DataRep ( DataRep ) -> DataRep
    
    Constructors for DataRep objects.   The first form creates a
    static version.   The second form creates a dynamic version
    bound to a DataSource with bindings taken from the strings in
    the sequence.  The final version makes a copy of existing
    DataRep.
    
    For the names of the types of DataRep classes available
    see names().
 
    C++ signature :
        void __init__(_object*,std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (str)arg2, (DataArray)arg3, (object)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,std::string,hippodraw::PyDataSource const*,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (DataRep)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyDataRep*)
__reduce__ = (...)
addCut(...)
addCut( (DataRep)arg1) -> None :
    addCut ( ) -> None
    
    Adds a cut to limit the region given to a fitter.
 
    C++ signature :
        void addCut(hippodraw::PyDataRep {lvalue})
applyCut(...)
applyCut( (DataRep)arg1, (Cut)arg2) -> None :
    applyCut ( Cut ) -> None
    
    Applies a Cut to limit the rows of the DataSource used by
    the Display.
 
    C++ signature :
        void applyCut(hippodraw::PyDataRep {lvalue},hippodraw::QtCut*)
applyCuts(...)
applyCuts( (DataRep)arg1, (object)arg2) -> None :
    applyCuts ( sequence ) -> None
    
    Applies a sequence of Cut object to limit the rows of
    the DataSource used by the Display.
 
    C++ signature :
        void applyCuts(hippodraw::PyDataRep {lvalue},std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >)
colorNames(...)
colorNames( (DataRep)arg1) -> object :
    colorNames () -> tuple
    
    Returns a list of available color names.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > colorNames(hippodraw::PyDataRep {lvalue})
createNTuple(...)
createNTuple( (DataRep)arg1) -> NTupleInternal :
    createNTuple () -> NTuple
    
    Creates and returns an NTuple representation of the object.
 
    C++ signature :
        hippodraw::NTuple const* createNTuple(hippodraw::PyDataRep {lvalue})
createNTupleUnderRegion(...)
createNTupleUnderRegion( (DataRep)arg1) -> NTupleInternal :
    createNTupleUnderRegion () -> NTuple
    
    Creates and returns a NTuple contain only rows that pass the
    region cuts.
 
    C++ signature :
        hippodraw::NTuplecreateNTupleUnderRegion(hippodraw::PyDataRep {lvalue})
getBinWidth(...)
getBinWidth( (DataRep)arg1, (str)arg2) -> float :
    getBinWidth ( string ) -> value
    Returns the bin width on specified axis. Only meaningful if
    object is histogram type.
 
    C++ signature :
        double getBinWidth(hippodraw::PyDataRep {lvalue},std::string)
getColumnWithCuts(...)
getColumnWithCuts( (DataRep)arg1, (str)arg2) -> object :
    getColumnWithCuts ( column ) -> tuple
    
    Creates and returns the named column, with cuts applied.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumnWithCuts(hippodraw::PyDataRep {lvalue},std::string)
getMean(...)
getMean( (DataRep)arg1, (str)arg2) -> float :
    getMean ( string ) -> value
    
    Returns the mean of the data along specified axis
 
    C++ signature :
        double getMean(hippodraw::PyDataRep {lvalue},std::string)
getNTupleWithCuts(...)
getNTupleWithCuts( (DataRep)arg1) -> NTupleInternal :
    getNTupleWithCuts () -> NTuple
    
    Creates and returns to NTuple being used, with cuts applied.
 
    C++ signature :
        hippodraw::NTuplegetNTupleWithCuts(hippodraw::PyDataRep {lvalue})
getRMS(...)
getRMS( (DataRep)arg1, (str)arg2) -> float :
    getRMS ( string ) -> value
    
    Returns root mean squared of data along specified axis
 
    C++ signature :
        double getRMS(hippodraw::PyDataRep {lvalue},std::string)
name(...)
name( (DataRep)arg1) -> str :
    name ( ) -> string
    
    Returns the type of DataRep.
 
    C++ signature :
        std::string name(hippodraw::PyDataRep {lvalue})
normalizeTo(...)
normalizeTo( (DataRep)arg1, (DataRep)arg2) -> None :
    normalizeTo ( DataRep ) -> None
    
    Sets the object to normalize itself to a target one
 
    C++ signature :
        void normalizeTo(hippodraw::PyDataRep {lvalue},hippodraw::PyDataRep const*)
numberOfEntries(...)
numberOfEntries( (DataRep)arg1) -> float :
    numberOfEntries ( ) -> value
    
    Returns the number of entries.
 
    C++ signature :
        double numberOfEntries(hippodraw::PyDataRep {lvalue})
set(...)
set( (DataRep)arg1, (ColorValue)arg2) -> None :
    set ( ColorValue ) -> None
    set ( Line ) -> None
    set ( Symbol ) -> None
    
    Sets the color, line style or Symbol of the RepBase object.
    Use ColorValue.values, Line.values, or Symbol.values to see
    available values.
 
    C++ signature :
        void set(hippodraw::PyDataRep {lvalue},hippodraw::Color::Value)
 
set( (DataRep)arg1, (Line)arg2) -> None :
 
    C++ signature :
        void set(hippodraw::PyDataRep {lvalue},hippodraw::Line::Style)
 
set( (DataRep)arg1, (Symbol)arg2) -> None :
 
    C++ signature :
        void set(hippodraw::PyDataRep {lvalue},hippodraw::Symbol::Type)
setAxisBinding(...)
setAxisBinding( (DataRep)arg1, (str)arg2, (str)arg3) -> None :
    setAxisBinding ( string, string ) -> None
    
    Sets an axis binding.  The first argument is the axis and the
    second is a label of a column in the DataSource.
 
    C++ signature :
        void setAxisBinding(hippodraw::PyDataRep {lvalue},std::string,std::string)
setAxisBindings(...)
setAxisBindings( (DataRep)arg1, (object)arg2) -> None :
    setAxisBindings ( string, sequence ) -> None
    
    Sets all the axes bindings.  The first argument is the axis and
    the sequence contains labels of columns in the DataSource.
 
    C++ signature :
        void setAxisBindings(hippodraw::PyDataRep {lvalue},std::vector<std::string, std::allocator<std::string> >)
setBinWidth(...)
setBinWidth( (DataRep)arg1, (str)arg2, (float)arg3) -> None :
    setBinWidth ( string, value ) -> None
    
    Sets the width of the bins, if data representation is binned.
    
 
    C++ signature :
        void setBinWidth(hippodraw::PyDataRep {lvalue},std::string,double)
setColor(...)
setColor( (DataRep)arg1, (str)arg2) -> None :
    setColor ( string ) -> None
    
    Sets the color of the point representation.
    See DataRep.colorNames() for list of available colors.
 
    C++ signature :
        void setColor(hippodraw::PyDataRep {lvalue},std::string)
setCutRange(...)
setCutRange( (DataRep)arg1, (float)arg2, (float)arg3) -> None :
    setCutRange ( low, high ) -> None
    
    Sets the low and high end of the region highlight
 
    C++ signature :
        void setCutRange(hippodraw::PyDataRep {lvalue},double,double)
setErrorDisplay(...)
setErrorDisplay( (DataRep)arg1, (str)arg2, (bool)arg3) -> None :
    setErrorDisplay ( string, boolean ) -> None
    
    Turns on or off display of error bars, if available, on
    specified axis.
 
    C++ signature :
        void setErrorDisplay(hippodraw::PyDataRep {lvalue},std::string,bool)
setLineStyle(...)
setLineStyle( (DataRep)arg1, (str)arg2) -> None :
    setLineStyle ( string ) -> None
    
    Sets the line style.
    This method is deprecated, use DataRep.set(Line) instead.
 
    C++ signature :
        void setLineStyle(hippodraw::PyDataRep {lvalue},std::string)
setPointRep(...)
setPointRep( (DataRep)arg1, (RepBase)arg2) -> None :
    setPointRep ( RepBase ) -> None
    
    Sets the point representation.
 
    C++ signature :
        void setPointRep(hippodraw::PyDataRep {lvalue},hippodraw::RepBase*)
setSize(...)
setSize( (DataRep)arg1, (float)arg2) -> None :
    setSize ( value ) -> None
    
    Sets the size of the point representation.
 
    C++ signature :
        void setSize(hippodraw::PyDataRep {lvalue},double)
setSymbol(...)
setSymbol( (DataRep)arg1, (str)arg2, (float)arg3) -> None :
    setSymbol ( string, value ) -> None
    
    Sets the point symbol and size. This method is deprecated, use
    DataRep.set(Symbol) and DataRep.setSize() instead.
 
    C++ signature :
        void setSymbol(hippodraw::PyDataRep {lvalue},std::string,float)
setWeight(...)
setWeight( (DataRep)arg1, (str)arg2) -> None :
    setWeight ( string ) -> None
    
    Sets the weight option if DataRep is a type of histogram.
    The string is a label of a column in the DataSource.
 
    C++ signature :
        void setWeight(hippodraw::PyDataRep {lvalue},std::string)

Static methods defined here:
names(...)
names() -> object :
    names () -> tuple
    
    Returns a tuple containing the names of the types of DataRep
    that are available.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > names()

Data and other attributes defined here:
__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class DataSource(Boost.Python.instance)
    This class is an abstract base class defining the data table,
called an ntuple.  That is a table with some number of columns and a
perhaps large number of rows. It implements some of the
but the actual data storage is done in a derived class.
 
 
Method resolution order:
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
clear(...)
clear( (DataSource)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::DataSource {lvalue})
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
replaceColumn(...)
replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( label, list ) -> None
    
    Replaces the column of data by abel.
 
    C++ signature :
        void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors defined here:
columns
rows

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Display(Boost.Python.instance)
    A wrapper for the HippoDraw PlotterBase C++ class.
See HippoDraw's QtDisplay documentation for more details.
 
 
Method resolution order:
Display
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1, (str)arg2) -> None :
    Display ( string ) -> Display
    Display ( string, DataSource, tuple ) -> Display
    Display ( string, DataArray, tuple ) - > Display
    Display ( string, tuple, tuple ) -> Display
    Display ( string, list, tuple ) -> Display
    Display ( string, RootNTuple, tuple ) -> Display
    Display ( string, RootNTuple, tuple, tuple ) -> Display
    
    This method is used to create a Display object.
    The first method is used for creating static version of
    Histogram, etc., where the string is the type of DataRep.
    The remaining methods are for dynamic versions.
    The string argument is the type.   The second argument
    is the DataSource and the third argument is tuple of
    string for the binding to the DataSource.
    For the last method, the fourth argument is a tuple
    of integers to access a RootNTuple array variable.
    
    For the names of the types of DataRep classes available
    call DataRep.names().
 
    C++ signature :
        void __init__(_object*,std::string)
 
__init__( (object)arg1, (Function)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyFunctionRep*)
 
__init__( (object)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,std::string,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (str)arg2, (DataArray)arg3, (object)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,std::string,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (str)arg2, (tuple)arg3, (object)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,std::string,boost::python::tuple,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (str)arg2, (list)arg3, (object)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,std::string,boost::python::list,std::vector<std::string, std::allocator<std::string> >)
__reduce__ = (...)
addDataRep(...)
addDataRep( (Display)arg1, (DataRep)arg2) -> None :
    addDataRep ( DataRep ) -> Display
    addDataRep ( Function ) -> Display
    addDataRep ( string, DataSource, tuple ) -> Display
    
    Adds a DataRep to the display sharing the same Y axis range
    The first two methods adds existing DataRep or Function to the
    Display.  The third method creates and adds DataRep to the
    Display.  Arguments are same as Display constructor.
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyDataRep*)
 
addDataRep( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
 
addDataRep( (Display)arg1, (Function)arg2) -> None :
 
    C++ signature :
        void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyFunctionRep*)
addDataRepStacked(...)
addDataRepStacked( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
    addDataRepStacked ( string, DataSource, tuple ) -> Display
    
    Creates and adds a DataRep with independent Y axis ranges.
    The arguments are the same as Display constructor.
 
    C++ signature :
        void addDataRepStacked(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
addFunction(...)
addFunction( (Display)arg1, (FunctionBase)arg2) -> None :
    addFunction ( FunctionBase ) -> None
    
    Adds a FunctionBase object to the display by appropriately
    wrapping it with a Function.
 
    C++ signature :
        void addFunction(hippodraw::QtDisplay {lvalue},hippodraw::FunctionBase*)
addObserver(...)
addObserver( (Display)arg1, (Observer)arg2) -> None :
    addObserver ( Observer ) -> None
    
    Adds an Observer to the Display object.
 
    C++ signature :
        void addObserver(hippodraw::QtDisplay {lvalue},hippodraw::Observer*)
addValues(...)
addValues( (Display)arg1, (object)arg2) -> None :
    addValue ( tuple ) -> None
    
    For static histograms, adds a value to the accumulation.
    For 1D histogram, the tuple should contain one or two values,
    the second used as a weight.  For 2D histogram, the tuple should
    contain two or three elements, the third being the weight.
    non static Displays do nothing.
 
    C++ signature :
        void addValues(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
applyCut(...)
applyCut( (Display)arg1, (Display)arg2) -> None :
    applyCut ( Cut ) -> None
    
    Apply a Cut to the Display
 
    C++ signature :
        void applyCut(hippodraw::QtDisplay {lvalue},hippodraw::QtDisplay*)
applyCuts(...)
applyCuts( (Display)arg1, (object)arg2) -> None :
    applyCuts ( sequence ) -> None
    
    Apply each Cut in the sequence to the Display
 
    C++ signature :
        void applyCuts(hippodraw::QtDisplay {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
createDataArray(...)
createDataArray( (Display)arg1) -> DataArray :
    createDataArray ( ) -> DataArray
    
    Returns a DataArray representation of the Display's contents
    (This method available if configured with numarray)
 
    C++ signature :
        hippodraw::PyDataSource* createDataArray(hippodraw::QtDisplay {lvalue})
createNTuple(...)
createNTuple( (Display)arg1) -> NTuple :
    createNTuple ( ) -> NTuple
    
    Returns a NTuple representation of the Display's contents.
 
    C++ signature :
        hippodraw::PyNTuple* createNTuple(hippodraw::QtDisplay {lvalue})
currentView(...)
currentView( (Display)arg1) -> int :
    currentView ( ) -> int
    
    Index of the current view.
 
    C++ signature :
        int currentView(hippodraw::QtDisplay {lvalue})
deleteView(...)
deleteView( (Display)arg1, (int)arg2) -> None :
    deleteView ( int ) -> None
    
    Delete a view by index.
 
    C++ signature :
        void deleteView(hippodraw::QtDisplay {lvalue},int)
getBinWidth(...)
getBinWidth( (Display)arg1, (str)arg2) -> float :
    getBinWidth ( string ) -> value
    
    Returns the bin width on axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        double getBinWidth(hippodraw::QtDisplay {lvalue},std::string)
getDataRep(...)
getDataRep( (Display)arg1) -> DataRep :
    getDataRep ( ) -> DataRep
    
    Returns a reference to the active DataRep or if all DataRep objects are
    active, returns a reference to the first one.
 
    C++ signature :
        hippodraw::PyDataRep* getDataRep(hippodraw::QtDisplay {lvalue})
getDataReps(...)
getDataReps( (Display)arg1) -> object :
    getDataReps ( ) -> list
    
    Returns a list of DataRep objects contained by the Display..
 
    C++ signature :
        std::vector<hippodraw::PyDataRep*, std::allocator<hippodraw::PyDataRep*> > getDataReps(hippodraw::QtDisplay {lvalue})
getLabel(...)
getLabel( (Display)arg1, (str)arg2) -> str :
    getLabel ( string ) -> string
    
    Returns the label of the axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        std::string getLabel(hippodraw::QtDisplay {lvalue},std::string)
getLog(...)
getLog( (Display)arg1, (str)arg2) -> int :
    getLog ( string ) -> value
    
    Returns True if axis specified as a string, e.g. 'x', is being
    displayed on a logarithmic scale.
 
    C++ signature :
        int getLog(hippodraw::QtDisplay {lvalue},std::string)
getRange(...)
getRange( (Display)arg1, (str)arg2) -> object :
    getRange ( string ) -> tuple
    
    Returns the tuple representing the range for the axis specified
    as a string, e.g., 'x'.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getRange(hippodraw::QtDisplay {lvalue},std::string)
getTitle(...)
getTitle( (Display)arg1) -> str :
    getTitle () -> string
    
    Returns the current title.   The title will be the title of
    the DataSource unless it has been explicitly changed.
 
    C++ signature :
        std::string getTitle(hippodraw::QtDisplay {lvalue})
nextView(...)
nextView( (Display)arg1, (bool)arg2) -> int :
    nextView ( bool ) -> int
    
    Cycle to the next view in the view buffer. Set the argument to True to cycle for wards, False to cycle back wards.
    Returns the index of the new view.
 
    C++ signature :
        int nextView(hippodraw::QtDisplay {lvalue},bool)
numViews(...)
numViews( (Display)arg1) -> int :
    numViews ( ) -> int
    
    Return the number of stored views.
 
    C++ signature :
        int numViews(hippodraw::QtDisplay {lvalue})
numberOfEntries(...)
numberOfEntries( (Display)arg1) -> float :
    numberOfEntries ( ) -> value
    
    Returns the number of entries in the Display.
 
    C++ signature :
        double numberOfEntries(hippodraw::QtDisplay {lvalue})
plotterId(...)
plotterId( (Display)arg1) -> int :
    plotterId () -> value
    
    Returns a unique identifier for the Display.
 
    C++ signature :
        int plotterId(hippodraw::QtDisplay {lvalue})
reset(...)
reset( (Display)arg1) -> None :
    reset () -> None
    
    Resets the contents of all bins.   Only applicable to static
    histograms.
 
    C++ signature :
        void reset(hippodraw::QtDisplay {lvalue})
resize(...)
resize( (Display)arg1) -> None :
    resize () -> None
    
    Resizes the Display to its saved values.
 
    C++ signature :
        void resize(hippodraw::QtDisplay {lvalue})
saveView(...)
saveView( (Display)arg1) -> int :
    saveView ( ) -> int
    
    Saves the current set of x and y ranges and returns the index of the saved view.
 
    C++ signature :
        int saveView(hippodraw::QtDisplay {lvalue})
setAspectRatio(...)
setAspectRatio( (Display)arg1, (float)arg2) -> None :
    setAspectRatio ( value ) -> None
    
    Sets the required aspect ratio of the Display to value, the
    ratio of the width to the height.
 
    C++ signature :
        void setAspectRatio(hippodraw::QtDisplay {lvalue},double)
setAutoRanging(...)
setAutoRanging( (Display)arg1, (str)arg2, (bool)arg3) -> None :
    setAutoRanging ( string, Boolean ) -> None
    
    Sets auto-ranging on axis specified as a string, e.g. 'x',non or off.
 
    C++ signature :
        void setAutoRanging(hippodraw::QtDisplay {lvalue},std::string,bool)
setAutoTicks(...)
setAutoTicks( (Display)arg1, (str)arg2, (bool)arg3) -> None :
    setAutoTicks ( Boolean ) -> None
    
    Set the ticks generation to be automatic (the default) or
    manually.
 
    C++ signature :
        void setAutoTicks(hippodraw::QtDisplay {lvalue},std::string,bool)
setBinWidth(...)
setBinWidth( (Display)arg1, (str)arg2, (float)arg3, (bool)arg4) -> None :
    Set the bin width, explicitly saving the value or not.
 
    C++ signature :
        void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double,bool)
 
setBinWidth( (Display)arg1, (str)arg2, (float)arg3) -> None :
    setBinWidth ( string, value ) -> None
    
    Set the bin width to value  on axis specified as a string,
    e.g., 'x'.
 
    C++ signature :
        void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double)
setColorMap(...)
setColorMap( (Display)arg1, (str)arg2) -> None :
    setColorMap ( string ) -> None
    
    Set the value-to-color map to one named by the argument.
 
    C++ signature :
        void setColorMap(hippodraw::QtDisplay {lvalue},std::string)
setContourLevels(...)
setContourLevels( (Display)arg1, (object)arg2) -> None :
    setContourLevels ( sequence ) -> None
    
    Sets the contour levels if the Display is using contour point
    representation from the values in the sequence.
 
    C++ signature :
        void setContourLevels(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
setLabel(...)
setLabel( (Display)arg1, (str)arg2, (str)arg3) -> None :
    setLabel ( string, string ) -> None
    
    Sets the label for the axis specified by first argument to value
    of the second argument.
 
    C++ signature :
        void setLabel(hippodraw::QtDisplay {lvalue},std::string,std::string)
setLog(...)
setLog( (Display)arg1, (str)arg2, (int)arg3) -> None :
    setLog ( string, Boolean ) -> None
    
    Sets the axis specified by the first argument on log scale.
 
    C++ signature :
        void setLog(hippodraw::QtDisplay {lvalue},std::string,int)
setNumberOfBins(...)
setNumberOfBins( (Display)arg1, (str)arg2, (int)arg3) -> None :
    setNumberOfBins ( string, value ) -> None
    
    Sets the number of bins on named axis, e.g. 'x' to the given 
    value.
 
    C++ signature :
        void setNumberOfBins(hippodraw::QtDisplay {lvalue},std::string,unsigned int)
setOffset(...)
setOffset( (Display)arg1, (str)arg2, (float)arg3) -> None :
    setOffset ( string, value ) -> None
    
    Sets the offset of the bins relative to their current width on
    specified axis.
 
    C++ signature :
        void setOffset(hippodraw::QtDisplay {lvalue},std::string,double)
setPointRep(...)
setPointRep( (Display)arg1, (RepBase)arg2) -> None :
    setPointRep ( RepBase ) -> None
    
    Sets the point representation to be used.
 
    C++ signature :
        void setPointRep(hippodraw::QtDisplay {lvalue},hippodraw::RepBase*)
setRange(...)
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
 
    C++ signature :
        void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double)
 
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4, (bool)arg5) -> None :
    setRange ( string, value, value ) -> None
    setRange ( string, value, value, Boolean ) -> None
    
    Set the upper and lower bounds for the specified axis.  For the
    second form, also save them if the Boolean argument is true.
 
    C++ signature :
        void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double,bool)
setTicks(...)
setTicks( (Display)arg1, (str)arg2, (object)arg3, (object)arg4) -> None :
    setTicks ( string, sequence, sequence ) -> None
    
    Sets the tick locations and labels.   The first argument is the
     axis, the second argument is a sequence containing the
    locations, and the third argument is a sequence of tick labels.
 
    C++ signature :
        void setTicks(hippodraw::QtDisplay {lvalue},std::string,std::vector<double, std::allocator<double> >,std::vector<std::string, std::allocator<std::string> >)
setTitle(...)
setTitle( (Display)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the display.
 
    C++ signature :
        void setTitle(hippodraw::QtDisplay {lvalue},std::string)
setTransform(...)
setTransform( (Display)arg1, (str)arg2) -> None :
    setTransform ( string ) -> None
    
    Sets the transform object.
 
    C++ signature :
        void setTransform(hippodraw::QtDisplay {lvalue},std::string)
setView(...)
setView( (Display)arg1, (int)arg2) -> None :
    setView ( int ) -> None
    
    Set the view by its index.
 
    C++ signature :
        void setView(hippodraw::QtDisplay {lvalue},int)
unlock(...)
unlock( (Display)arg1) -> None :
    unlock () -> None
    
    Unlock the application thread.
 
    C++ signature :
        void unlock(hippodraw::QtDisplay {lvalue})
update(...)
update( (Display)arg1) -> None :
    update () -> None
    
    Updates the display.
 
    C++ signature :
        void update(hippodraw::QtDisplay {lvalue})

Data and other attributes defined here:
__instance_size__ = 72

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FCNBase(Boost.Python.instance)
    The base class for the objective function used in fitting.
 
 
Method resolution order:
FCNBase
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FactoryPointRep(Boost.Python.instance)
    A private base class for PointRepFactory.
 
 
Method resolution order:
FactoryPointRep
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FitsController(Boost.Python.instance)
    A class for creation of DataSource objects from a FITS file.
 
 
Method resolution order:
FitsController
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
createDataArray(...)
createDataArray( (FitsController)arg1, (str)arg2, (str)arg3) -> DataArray :
    createDataArray ( string, string ) -> DataArray
    
    Creates DataArray from a file with key name
 
    C++ signature :
        hippodraw::PyDataSource* createDataArray(hippodraw::PyFitsController {lvalue},std::string,std::string)
createNTuple(...)
createNTuple( (FitsController)arg1, (str)arg2, (str)arg3) -> FitsNTuple :
    createNTuple ( string, string ) -> FitsNTuple
    
    Creates FitsNTuple from the named file with key name.  Python 
    take possession of it.
 
    C++ signature :
        hippodraw::FitsNTuplecreateNTuple(hippodraw::PyFitsController {lvalue},std::string,std::string)
getNTupleNames(...)
getNTupleNames( (FitsController)arg1, (str)arg2) -> object :
    getNTupleNames ( string ) -> sequence
    
    Returns the names of the HDU data source objects in the file.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getNTupleNames(hippodraw::PyFitsController {lvalue},std::string)
writeToFile(...)
writeToFile( (FitsController)arg1, (DataArray)arg2, (str)arg3) -> None :
    writeToFile ( DataArray, filename ) -> None.
    writeToFile ( DataSource, filename ) -> None,
    writeToFile ( DataArray, filename, tuple, tuple ) -> None.
    writeToFile ( DataSource, filename, tuple, tuple ) -> None,
    
    Writes a DataSource or DataArray to FITS file as binary table.
    In the latter two forms, the first tuple is list of Cuts and
    and the second is tuple of column labels
 
    C++ signature :
        void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::PyDataSource const*,std::string)
 
writeToFile( (FitsController)arg1, (DataSource)arg2, (str)arg3) -> None :
 
    C++ signature :
        void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::DataSource const*,std::string)
 
writeToFile( (FitsController)arg1, (DataSource)arg2, (str)arg3, (object)arg4, (object)arg5) -> None :
 
    C++ signature :
        void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::DataSource const*,std::string,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,std::vector<std::string, std::allocator<std::string> >)
 
writeToFile( (FitsController)arg1, (DataArray)arg2, (str)arg3, (object)arg4, (object)arg5) -> None :
 
    C++ signature :
        void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::PyDataSource const*,std::string,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,std::vector<std::string, std::allocator<std::string> >)

Static methods defined here:
instance(...)
instance() -> FitsController :
    instance () -> FitsController
    
    Returns the single instance of the controller.
 
    C++ signature :
        hippodraw::PyFitsController* instance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FitsNTuple(DataSource)
    a derived class of DataSource that references a table or image in a
FITS file.  A FitNTuple object must be created by the FitsController.Changes made to this object will not be reflected in the FITS file.
 
 
Method resolution order:
FitsNTuple
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
addColumn(...)
addColumn( (FitsNTuple)arg1, (str)arg2, (object)arg3) -> int :
    addColumn ( string, list or tuple ) -> value
    
    Adds a column to the data source. The string argument is used
    for the label of the new column.   The length of the new column
    must the same as existing columns.   The value returns is the
    index to the column.
 
    C++ signature :
        int addColumn(hippodraw::FitsNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
replaceColumn(...)
replaceColumn( (FitsNTuple)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( index, list ) -> None
    replaceColumn ( label, list ) -> None
    
    Replaces the column of data by index or label.   Does not
    modify the FITS file.
 
    C++ signature :
        void replaceColumn(hippodraw::FitsNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
 
replaceColumn( (FitsNTuple)arg1, (int)arg2, (object)arg3) -> None :
 
    C++ signature :
        void replaceColumn(hippodraw::FitsNTuple {lvalue},unsigned int,std::vector<double, std::allocator<double> >)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Methods inherited from DataSource:
clear(...)
clear( (DataSource)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::DataSource {lvalue})
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from DataSource:
columns
rows

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Fitter(Boost.Python.instance)
    Provides an interface to objective function minimizers.
 
 
Method resolution order:
Fitter
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
getFCN(...)
getFCN( (Fitter)arg1) -> StatedFCN :
    getFCN () -> FCNBase
    
    Returns the objective function.
 
    C++ signature :
        hippodraw::StatedFCNgetFCN(hippodraw::Fitter {lvalue})
minimize(...)
minimize( (Fitter)arg1) -> bool :
    minimize () -> Boolean
    
    Attempts to do a minimization, returns True if successful.
 
    C++ signature :
        bool minimize(hippodraw::Fitter {lvalue})
name(...)
name( (Fitter)arg1) -> str :
    name () -> string
    
    Returns the minimizer name.
 
    C++ signature :
        std::string name(hippodraw::Fitter {lvalue})
setFixedFlags(...)
setFixedFlags( (Fitter)arg1, (object)arg2) -> None :
    setFixedFlags ( sequence ) -> None
    
    Sets which parameters that should be fixed during a fit.   A
    `1' in the sequence indicates corresponding parameters is fixed.
 
    C++ signature :
        void setFixedFlags(hippodraw::Fitter {lvalue},std::vector<int, std::allocator<int> >)
setLimits(...)
setLimits( (Fitter)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :
 
    C++ signature :
        void setLimits(hippodraw::Fitter {lvalue},unsigned int,double,double)
 
setLimits( (Fitter)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
    setLimits ( name, low, high ) -> None
    setLimits ( index, low, high ) -> None
    
    Sets the limits on a model function parameter.  Only minimizers
    based on Minuit support this feature, others throw an exception.
 
    C++ signature :
        void setLimits(hippodraw::Fitter {lvalue},std::string,double,double)
setStepSize(...)
setStepSize( (Fitter)arg1, (int)arg2, (float)arg3) -> None :
 
    C++ signature :
        void setStepSize(hippodraw::Fitter {lvalue},unsigned int,double)
 
setStepSize( (Fitter)arg1, (str)arg2, (float)arg3) -> None :
    setStepSize ( name, value ) -> None
    setStepSize ( index, value ) -> None
    
    Sets the step size for the model function parameter.   Only
    minimizers based on Minuit support this function, others
    throw an exception.
 
    C++ signature :
        void setStepSize(hippodraw::Fitter {lvalue},std::string,double)

Data descriptors defined here:
degreesOfFreedom
objectiveValue

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FitterFactory(Boost.Python.instance)
    The factory for returning fitters preloaded with objective functions.
 
 
Method resolution order:
FitterFactory
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
create(...)
create( (FitterFactory)arg1, (str)arg2) -> Fitter :
    create ( string ) -> Fitter
    
    Returns the newly created fitter object.
 
    C++ signature :
        hippodraw::Fittercreate(hippodraw::FitterFactory {lvalue},std::string)
names(...)
names( (FitterFactory)arg1) -> object :
    names () -> sequence
    
    Returns the names of the available fitters.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > names(hippodraw::FitterFactory {lvalue})
setDefault(...)
setDefault( (FitterFactory)arg1, (str)arg2) -> None :
    setDefault ( string ) -> None
    
    Sets the default fitter object.   Throws an exception if given
    invalid name.
 
    C++ signature :
        void setDefault(hippodraw::FitterFactory {lvalue},std::string)

Static methods defined here:
instance(...)
instance() -> FitterFactory :
    instance () -> FitterFactory
    
    Returns the single instance of the FitterFactory
 
    C++ signature :
        hippodraw::FitterFactoryinstance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Function(Boost.Python.instance)
    This class wraps a FunctionBase object with a DataRep. This allows
it to be drawn in a Display.   It also provides interface to member
functions of FunctionBase, although the user could obtain a
reference to the FunctionBase itself to do so.
 
 
Method resolution order:
Function
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1, (str)arg2, (DataRep)arg3) -> None :
    Function ( string,  DataRep ) -> Function
    Function ( FunctionBaseDataRep ) -> Function
    
    The first form creates a function using the string to find the
    FunctionBase in the FunctionFactory.   The second form creates a
    using an existing FunctionBase object.   Both forms use the DataRep
    as target for fitting and drawing
    
 
    C++ signature :
        void __init__(_object*,std::string,hippodraw::PyDataRep*)
 
__init__( (object)arg1, (FunctionBase)arg2 [, (DataRep)arg3]) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::FunctionBase* [,hippodraw::PyDataRep*])
__reduce__ = (...)
addTo(...)
addTo( (Function)arg1, (Display)arg2) -> None :
    addTo ( Display ) -> None
    
    Adds the Function to a Display. taking the Display's selected
    DataRep as its target.
 
    C++ signature :
        void addTo(hippodraw::PyFunctionRep {lvalue},hippodraw::QtDisplay*)
chiSquared(...)
chiSquared( (Function)arg1) -> float :
    chiSquare ( None ) -> value
    
    Returns the Chi-Squared.
 
    C++ signature :
        double chiSquared(hippodraw::PyFunctionRep {lvalue})
createResidualsDisplay(...)
createResidualsDisplay( (Function)arg1) -> Display :
    createResidualsDisplay ( None ) -> Display
    
    Returns residuals Display object. The residuals display is an
    XY plot showing the difference between the function values and
    the target DataRep values.
 
    C++ signature :
        hippodraw::QtDisplay* createResidualsDisplay(hippodraw::PyFunctionRep {lvalue})
degreesOfFreedom(...)
degreesOfFreedom( (Function)arg1) -> int :
    degressOfFreedom ( None ) -> value
    
    Returns the number of degrees of freedom a fitter would have.
 
    C++ signature :
        int degreesOfFreedom(hippodraw::PyFunctionRep {lvalue})
errors(...)
errors( (Function)arg1) -> object :
    errors ( None ) - > list
    
    Returns the errors on the parameters.  The errors are calculated
    by a fitter, thus the values returned are only valid after
    having done a fit.
 
    C++ signature :
        std::vector<double, std::allocator<double> > errors(hippodraw::PyFunctionRep {lvalue})
fit(...)
fit( (Function)arg1) -> bool :
    fit ( None ) -> boolean
    
    Attempts to fit the the function to the target DataRep.
    Uses the currently selected fitter, unless one was explicitly
    set.  Note the fit is always done to linear sum if more than one
    function is on the data.
 
    C++ signature :
        bool fit(hippodraw::PyFunctionRep {lvalue})
getFitterName(...)
getFitterName( (Function)arg1) -> str :
    getFitterName ( None ) -> string
    
    Returns the current fitter name.
 
    C++ signature :
        std::string getFitterName(hippodraw::PyFunctionRep {lvalue})
objectiveValue(...)
objectiveValue( (Function)arg1) -> float :
    objectiveValue ( None ) -> value
    
    Returns the objective Value that the fitter minimizes.
    Typically it is the Chi-Squared.
 
    C++ signature :
        double objectiveValue(hippodraw::PyFunctionRep {lvalue})
parameters(...)
parameters( (Function)arg1) -> object :
    parameters ( None ) -> list
    
    Returns a list of the function's parameter values.
 
    C++ signature :
        std::vector<double, std::allocator<double> > parameters(hippodraw::PyFunctionRep {lvalue})
parmNames(...)
parmNames( (Function)arg1) -> object :
    parmNames ( None ) -> list
    
    Returns a list of parameter names.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > parmNames(hippodraw::PyFunctionRep {lvalue})
principleErrors(...)
principleErrors( (Function)arg1) -> object :
    principleErrors ( None ) -> list
    
    Returns the errors on the parameters.
 
    C++ signature :
        std::vector<double, std::allocator<double> > principleErrors(hippodraw::PyFunctionRep {lvalue})
setFitRange(...)
setFitRange( (Function)arg1, (float)arg2, (float)arg3) -> None :
    setFitRange ( low, high ) -> None
    
    Sets the range of the coordinate axis that is used for fitting.
 
    C++ signature :
        void setFitRange(hippodraw::PyFunctionRep {lvalue},double,double)
setFitRangeEnabled(...)
setFitRangeEnabled( (Function)arg1, (bool)arg2) -> None :
    setFitRange ( boolean ) -> None
    
    Enabled use of the fit range
 
    C++ signature :
        void setFitRangeEnabled(hippodraw::PyFunctionRep {lvalue},bool)
setFitter(...)
setFitter( (Function)arg1, (str)arg2) -> None :
    setFitter ( string ) -> None
    
    Sets the fitter by name from fitter factory.
 
    C++ signature :
        void setFitter(hippodraw::PyFunctionRep {lvalue},std::string)
setFixedFlags(...)
setFixedFlags( (Function)arg1, (object)arg2) -> None :
    setFixedFlags ( list ) -> None
    
    Set which parameters should be held fixed during fitting.
 
    C++ signature :
        void setFixedFlags(hippodraw::PyFunctionRep {lvalue},std::vector<int, std::allocator<int> >)
setParameters(...)
setParameters( (Function)arg1, (object)arg2) -> None :
    setParameters ( list ) -> None
    
    Sets the function's parameter values.
 
    C++ signature :
        void setParameters(hippodraw::PyFunctionRep {lvalue},std::vector<double, std::allocator<double> >)
valueAt(...)
valueAt( (Function)arg1, (float)arg2) -> float :
    valueAt ( x ) -> value
    
    Returns the function's value at given coordinate.
 
    C++ signature :
        double valueAt(hippodraw::PyFunctionRep {lvalue},double)

Data and other attributes defined here:
__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FunctionBase(Boost.Python.instance)
    The base class for raw functions.   FunctionBase objects need to
wrapped with Function objects to be displayed.   FunctionBase
can be derived from and cloned so they can be added to the
FunctionFactory.
 
 
Method resolution order:
FunctionBase
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1, (FunctionBase)arg2) -> None :
    FunctionBase () -> FunctionBase
    FunctionBase ( FunctionBase ) -> FunctionBase
    
    Constructors of the FunctionBase object.
    
 
    C++ signature :
        void __init__(_object*,hippodraw::FunctionBase)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (FunctionBase)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::FunctionWrap)
__reduce__ = (...)
getParameters(...)
getParameters( (FunctionBase)arg1) -> object :
    getParameters () -> sequence
    
    Returns the current function parameter values.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getParameters(hippodraw::FunctionBase {lvalue})
initialize(...)
initialize( (FunctionBase)arg1) -> None :
    initialize () -> None
    
    Initializes the function parameter values and the names.
    The number of parameters is taken from the number of names.
 
    C++ signature :
        void initialize(hippodraw::FunctionWrap {lvalue})
name(...)
name( (FunctionBase)arg1) -> str :
    name () -> string
    
    Returns the name of the function.
 
    C++ signature :
        std::string name(hippodraw::FunctionBase {lvalue})
parmNames(...)
parmNames( (FunctionBase)arg1) -> object :
    parmNames () -> sequence
    
    Returns the names of the parameters
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > parmNames(hippodraw::FunctionBase {lvalue})
setName(...)
setName( (FunctionBase)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the function.
 
    C++ signature :
        void setName(hippodraw::FunctionWrap {lvalue},std::string)
setParameters(...)
setParameters( (FunctionBase)arg1, (object)arg2) -> None :
    setParameters ( sequence ) -> None
    
    Sets the values of the parameters.
 
    C++ signature :
        void setParameters(hippodraw::FunctionBase {lvalue},std::vector<double, std::allocator<double> >)
setParmNames(...)
setParmNames( (FunctionBase)arg1, (object)arg2) -> None :
    setParmNames ( sequence ) -> None
    
    Sets the parameter names and re-sizes the parameters
 
    C++ signature :
        void setParmNames(hippodraw::FunctionWrap {lvalue},std::vector<std::string, std::allocator<std::string> >)

Data and other attributes defined here:
__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class FunctionFactory(Boost.Python.instance)
    The factory for creating derived classes of FunctionBase.
 
 
Method resolution order:
FunctionFactory
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
add(...)
add( (FunctionFactory)arg1, (FunctionBase)arg2) -> None :
    add ( FunctionBase ) -> None
    
    Adds the function to the factory.
 
    C++ signature :
        void add(hippodraw::FunctionFactory {lvalue},hippodraw::FunctionBase*)
create(...)
create( (FunctionFactory)arg1, (str)arg2) -> FunctionBase :
    create ( string ) -> FunctionBase
    
    Returns the newly created object derived from FunctionBase.
 
    C++ signature :
        hippodraw::FunctionBasecreate(hippodraw::FunctionFactory {lvalue},std::string)
names(...)
names( (FunctionFactory)arg1) -> object :
    names () -> sequence
    
    Returns the names of the available FunctinBase derived classes.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > names(hippodraw::FunctionFactory {lvalue})

Static methods defined here:
instance(...)
instance() -> FunctionFactory :
    instance () -> FunctionFactory
    
    Returns the single instance of the FunctionFactory.
 
    C++ signature :
        hippodraw::FunctionFactoryinstance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class HDApp(Boost.Python.instance)
    The HippoDraw application class.
 
 
Method resolution order:
HDApp
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
    HDApp () -> HDApp
    HDApp ( value ) -> HDApp
    
    Using the constructor with no arguments creates
    a HippoDraw application that runs in a separate
    thread.
    Using the constructor with one argument creates
    a HippoDraw application in same thread. Use
    app.exec_loop() to start it.
 
    C++ signature :
        void __init__(_object*,int)
 
__init__( (object)arg1, (str)arg2) -> None :
    HDapp ( string ) -> HDapp
 
    C++ signature :
        void __init__(_object*,char*)
__reduce__ = (...)
canvas(...)
canvas( (HDApp)arg1) -> Canvas :
    canvas () -> Canvas
    
    Returns the current canvas window.
 
    C++ signature :
        hippodraw::PyCanvas* canvas(hippodraw::PyApp {lvalue})
exec_loop(...)
exec_loop( (HDApp)arg1) -> int :
    exec_loop () -> value
    
    Starts the application object.  Returns the value returned
    by the application object upon exiting.
 
    C++ signature :
        int exec_loop(hippodraw::PyApp {lvalue})
hasTerminated(...)
hasTerminated( (HDApp)arg1) -> bool :
    hasTerminated () -> Boolean
    
    Returns True if the application has terminated.
 
    C++ signature :
        bool hasTerminated(hippodraw::PyApp {lvalue})
lock(...)
lock() -> None :
    lock () -> None
    
    Lock the Qt library Mutex.   Will not return until no
    other thread has the lock.
 
    C++ signature :
        void lock()
openDocument(...)
openDocument( (HDApp)arg1, (str)arg2) -> None :
    openDocument ( string ) -> None
    
    Opens new canvas window from saved document file.
 
    C++ signature :
        void openDocument(hippodraw::PyApp {lvalue},std::string)
quit(...)
quit( (HDApp)arg1) -> None :
    quit () -> None
    
    Closes all Canvas windows and Terminates the application.
 
    C++ signature :
        void quit(hippodraw::PyApp {lvalue})
quitOnLastWindowClose(...)
quitOnLastWindowClose( (HDApp)arg1, (bool)arg2) -> None :
    quitOnLastWindowClose ( Boolean ) -> None
    
    If argument is True, allows application to quit when last
    Canvas is closed.
 
    C++ signature :
        void quitOnLastWindowClose(hippodraw::PyApp {lvalue},bool)
unlock(...)
unlock() -> None :
    unlock () -> None
    
    Unlocks the application thread.
 
    C++ signature :
        void unlock()

Static methods defined here:
instance(...)
instance() -> HDApp :
    instance () -> HDApp
    
    Returns a singleton instance of the HippoDraw 
    application object
 
    C++ signature :
        hippodraw::PyApp* instance()

Data and other attributes defined here:
__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Line(Boost.Python.enum)
    
Method resolution order:
Line
Boost.Python.enum
__builtin__.int
__builtin__.object

Data and other attributes defined here:
dash = hippo.Line.dash
dashdot = hippo.Line.dashdot
dashdotdot = hippo.Line.dashdotdot
dot = hippo.Line.dot
invisible = hippo.Line.invisible
solid = hippo.Line.solid
values = {0: hippo.Line.solid, 1: hippo.Line.dash, 2: hippo.Line.dot, 3: hippo.Line.dashdot, 4: hippo.Line.dashdotdot, 5: hippo.Line.invisible}

Methods inherited from Boost.Python.enum:
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data descriptors inherited from Boost.Python.enum:
name

Methods inherited from __builtin__.int:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__trunc__(...)
Truncating an Integral returns itself.
__xor__(...)
x.__xor__(y) <==> x^y
conjugate(...)
Returns self, the complex conjugate of any int.

Data descriptors inherited from __builtin__.int:
denominator
the denominator of a rational number in lowest terms
imag
the imaginary part of a complex number
numerator
the numerator of a rational number in lowest terms
real
the real part of a complex number

Data and other attributes inherited from __builtin__.int:
__new__ = <built-in method __new__ of type object at 0xf7f5d8e0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class ListTuple(DataSource)
    A derived class from DataSource containing columns as references to
Python list objects.  This allows the data to be used without making
a copy of it.   However, access to the data is slower than for most
of the other classes derived from DataSource
 
 
Method resolution order:
ListTuple
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
    ListTuple ( None ) -> ListTuple
    
    Creates an empty ListTuple
 
    C++ signature :
        void __init__(_object*)
__reduce__ = (...)
addColumn(...)
addColumn( (ListTuple)arg1, (str)arg2, (list)arg3) -> int :
    addColumn ( string, list ) -> value
    
    Adds the array as a new column with label from the string.
    Returns the index of the new column.
 
    C++ signature :
        int addColumn(hippodraw::ListTuple {lvalue},std::string,boost::python::list)
getLabel(...)
getLabel( (ListTuple)arg1, (int)arg2) -> str :
    getLabel ( index ) -> string
    
    Returns label of column.
 
    C++ signature :
        std::string getLabel(hippodraw::ListTuple {lvalue},unsigned int)
notifyObservers(...)
notifyObservers( (ListTuple)arg1) -> None :
    notifyObservers ( None ) -> None
    
    Sends update message to all observers.  Use this member if the
    contents of the reference Python list has changed and Display
    objects bound to it require updating.
 
    C++ signature :
        void notifyObservers(hippodraw::ListTuple {lvalue})
replaceColumn(...)
replaceColumn( (ListTuple)arg1, (int)arg2, (list)arg3) -> None :
    replaceColumn ( index, list ) -> None
    
    Replaces existing column with list
    
 
    C++ signature :
        void replaceColumn(hippodraw::ListTuple {lvalue},unsigned int,boost::python::list)
 
replaceColumn( (ListTuple)arg1, (str)arg2, (list)arg3) -> None :
    replaceColumn ( string, list ) -> None
    
    Replaces existing column with new array
    
 
    C++ signature :
        void replaceColumn(hippodraw::ListTuple {lvalue},std::string,boost::python::list)
setLabels(...)
setLabels( (ListTuple)arg1, (object)arg2) -> None :
    setLabels ( list or tuple ) -> None
    
    Sets the labels of the columns from list of string objects.
    For an empty ListTuple object, implicitly sets the number of
    columns.
 
    C++ signature :
        void setLabels(hippodraw::ListTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)

Data and other attributes defined here:
__instance_size__ = 104

Methods inherited from DataSource:
clear(...)
clear( (DataSource)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::DataSource {lvalue})
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from DataSource:
columns
rows

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class NTuple(NTupleInternal)
    A derived class of DataSource that stores its tabular data vectors of
double precision numbers in C++.  An NTuple object can be created in
a number of ways including reading from a file using the
NTupleController
 
 
Method resolution order:
NTuple
NTupleInternal
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
    NTuple ( None ) -> NTuple
    NTuple ( value ) -> NTuple
    NTuple ( sequence ) -> NTuple
    NTuple ( NTuple ) -> NTuple
    
    The form with no arguments creates an empty NTuple with no rows
    or columns.   The form with one value argument creates an empty
    NTuple with `value' number of columns.   The form with a sequence
    argument creates an empty NTuple with the number of columns equal
    to size of the sequence.   The sequence should contain string which
    are used as the column labels.   The last form form creates an
    NTuple
     whose contents is a copy of an existing one.
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,unsigned int)
 
__init__( (object)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (NTuple)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::PyNTuple)
__reduce__ = (...)
addColumn(...)
addColumn( (NTuple)arg1, (str)arg2, (object)arg3) -> int :
    addColumn ( label, sequence ) -> index
    
    Adds a new column with label.
 
    C++ signature :
        int addColumn(hippodraw::PyNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
addRow(...)
addRow( (NTuple)arg1, (object)arg2) -> None :
    addRow ( sequence ) -> None
    
    Append a row at the end.
 
    C++ signature :
        void addRow(hippodraw::PyNTuple {lvalue},std::vector<double, std::allocator<double> >)
append(...)
append( (NTuple)arg1, (DataSource)arg2) -> None :
    append ( DataSource ) -> None
    
    Appends the contents of the DataSource to the NTuple.
 
    C++ signature :
        void append(hippodraw::PyNTuple {lvalue},hippodraw::DataSource const*)
clear(...)
clear( (NTuple)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::PyNTuple {lvalue})
replaceColumn(...)
replaceColumn( (NTuple)arg1, (int)arg2, (object)arg3) -> None :
    replaceColumn ( index, sequence ) -> None
    
    Replaces the indexed column.
 
    C++ signature :
        void replaceColumn(hippodraw::PyNTuple {lvalue},unsigned int,std::vector<double, std::allocator<double> >)
 
replaceColumn( (NTuple)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( label, sequence ) -> None
    
    Replaces the labeled  column.
 
    C++ signature :
        void replaceColumn(hippodraw::PyNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
setTitle(...)
setTitle( (NTuple)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::PyNTuple {lvalue},std::string)

Data and other attributes defined here:
__instance_size__ = 116

Methods inherited from NTupleInternal:
getLabel(...)
getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
    getLabel ( index ) -> string
    
    Returns the label at column index.
 
    C++ signature :
        std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
getRow(...)
getRow( (NTupleInternal)arg1, (int)arg2) -> object :
    getRow ( index ) -> list
    
    Returns the index row as list floats.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
setIntervalCount(...)
setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
    setIntervalCount ( count ) -> None
    
    Sets the interval count between updates to the observers.
 
    C++ signature :
        void setIntervalCount(hippodraw::NTuple {lvalue},int)
setIntervalEnabled(...)
setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
    setIntervalEnable ( Boolean ) -> None
    
    Sets the interval counting on or off
 
    C++ signature :
        void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
setLabels(...)
setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
    setLabels ( sequence ) -> None
    
    Sets the labels of the columns from the list of strings.  If the
    NTuple is empty, then also sets the number of columns to be the
    size of the list.   If the number of columns has already been
    set, the the size of the list should be the same, otherwise
    a RuntimeError exception is thrown.
 
    C++ signature :
        void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)

Methods inherited from DataSource:
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from DataSource:
columns
rows

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class NTupleController(Boost.Python.instance)
    A singleton object to manage NTuple objects.
 
 
Method resolution order:
NTupleController
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
changeName(...)
changeName( (NTupleController)arg1, (DataSource)arg2, (str)arg3) -> None :
    changeName ( DataSource, string ) -> None
    
    Change the name of an NTuple.
    This method is deprecated, there's not need to do this
 
    C++ signature :
        void changeName(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*,std::string)
createCircularBuffer(...)
createCircularBuffer( (NTupleController)arg1, (int)arg2) -> CircularBuffer :
    createCircularBuffer ( value ) -> CircularBuffer
    
    Creates and registers a CircularBuffer object with set number of
    columns.
 
    C++ signature :
        hippodraw::CircularBuffercreateCircularBuffer(hippodraw::PyNTupleController {lvalue},unsigned int)
createDataArray(...)
createDataArray( (NTupleController)arg1, (str)arg2) -> DataArray :
    createDataArray ( filename ) -> DataArray
    
    Creates a DataArray from file.
 
    C++ signature :
        hippodraw::PyDataSource* createDataArray(hippodraw::PyNTupleController {lvalue},std::string)
createNTuple(...)
createNTuple( (NTupleController)arg1) -> NTupleInternal :
    Creates an empty NTuple
 
    C++ signature :
        hippodraw::NTuplecreateNTuple(hippodraw::PyNTupleController {lvalue})
 
createNTuple( (NTupleController)arg1, (str)arg2) -> DataSource :
    createNTuple () -> NTuple
    createNTuple ( string ) -> NTuple
    
    Creates and registers an NTuple.   The first method creates an
    empty NTuple object.   The second method creates one from a
    file.  Both methods return ownership of the created object to
    Python.
 
    C++ signature :
        hippodraw::DataSourcecreateNTuple(hippodraw::PyNTupleController {lvalue},std::string)
findNTuple(...)
findNTuple( (NTupleController)arg1, (str)arg2) -> DataSource :
    findNTuple ( string ) -> DataSource
    
    Find an registered NTuple by its name and returns a reference to
    it.  If the DataSource can not be found, an exception is thrown.
    
    Warning: if more than one DataSource has the same name,
    the first one found is returned.
 
    C++ signature :
        hippodraw::DataSourcefindNTuple(hippodraw::PyNTupleController {lvalue},std::string)
registerNTuple(...)
registerNTuple( (NTupleController)arg1, (DataSource)arg2) -> str :
    Register an NTuple to make it visible to the application
 
    C++ signature :
        std::string registerNTuple(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*)
 
registerNTuple( (NTupleController)arg1, (str)arg2, (DataSource)arg3) -> None :
    registerNTuple ( DataSource ) -> None
    registerNTuple ( string, DataSource ) -> None
    
    Register an NTuple to make it visible to the application.   The
    first form takes the name from the DataSource object, if it has
    one, otherwise generates a unique name.   The second form takes
    string argument for the name.
 
    C++ signature :
        void registerNTuple(hippodraw::PyNTupleController {lvalue},std::string,hippodraw::DataSource*)
writeToFile(...)
writeToFile( (NTupleController)arg1, (DataSource)arg2, (str)arg3) -> int :
    writeToFile ( DataSource, string ) -> value
    
    Writes the NTuple to a file as ASCII text.   Returns 0 if
    successful.
 
    C++ signature :
        int writeToFile(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*,std::string)

Static methods defined here:
instance(...)
instance() -> NTupleController :
    instance () -> NTupleController
    
    Returns the single instance of the controller
 
    C++ signature :
        hippodraw::PyNTupleController* instance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class NTupleFCN(StatedFCN)
    A objective function class used in fitting that uses a DataSource to
access the data
 
 
Method resolution order:
NTupleFCN
StatedFCN
FCNBase
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
setDataSource(...)
setDataSource( (NTupleFCN)arg1, (DataSource)arg2) -> None :
 
    C++ signature :
        void setDataSource(hippodraw::NTupleFCN {lvalue},hippodraw::DataSource const*)
 
setDataSource( (NTupleFCN)arg1, (DataSource)arg2, (int)arg3, (object)arg4) -> None :
    setDataSource ( DataSource ) -> None
    setDataSource ( DataSource, value, sequence ) -> None
    
    The first form sets the data source with default indexes.  The
    second form takes in addition the dimensionality of the
    coordinate and a column indexes from the sequence.
 
    C++ signature :
        void setDataSource(hippodraw::NTupleFCN {lvalue},hippodraw::DataSource const*,int,std::vector<int, std::allocator<int> >)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Methods inherited from StatedFCN:
degreesOfFreedom(...)
degreesOfFreedom( (StatedFCN)arg1) -> int :
    degreesOfFreedom () -> value
    
    Returns the degrees of freedom as integer.
 
    C++ signature :
        int degreesOfFreedom(hippodraw::StatedFCN {lvalue})
objectiveValue(...)
objectiveValue( (StatedFCN)arg1) -> float :
    objectiveValue () -> value
    
    Returns the objective value.   For example, the objective
    might be the Chi-Squared when derived class returns it as
    its objective value.
 
    C++ signature :
        double objectiveValue(hippodraw::StatedFCN {lvalue})
setFunction(...)
setFunction( (StatedFCN)arg1, (FunctionBase)arg2) -> None :
    setFunction ( FunctionBase ) -> None
    
    Sets the model function.
 
    C++ signature :
        void setFunction(hippodraw::StatedFCN {lvalue},hippodraw::FunctionBase*)
setUseErrors(...)
setUseErrors( (StatedFCN)arg1, (bool)arg2) -> bool :
    setUseErrors ( Boolean ) -> None
    
    Sets the FCN to use errors on the data source if they exist.
 
    C++ signature :
        bool setUseErrors(hippodraw::StatedFCN {lvalue},bool)

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class NTupleInternal(DataSource)
    A derived class of DataSource that stores its tabular data vectors of
double precision numbers in C++.  An NTuple object can be created in
a number of ways including reading from a file using the
NTupleController
 
 
Method resolution order:
NTupleInternal
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
    NTuple ( None ) -> NTuple
    NTuple ( value ) -> NTuple
    NTuple ( sequence ) -> NTuple
    NTuple ( NTuple ) -> NTuple
    
    The form with no arguments creates an empty NTuple with no rows
    or columns.   The form with one value argument creates an empty
    NTuple with `value' number of columns.   The form with a sequence
    argument creates an empty NTuple with the number of columns equal
    to size of the sequence.   The sequence should contain string which
    are used as the column labels.   The last form form creates an
    NTuple
     whose contents is a copy of an existing one.
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,unsigned int)
 
__init__( (object)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
 
__init__( (object)arg1, (NTupleInternal)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,hippodraw::NTuple)
__reduce__ = (...)
getLabel(...)
getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
    getLabel ( index ) -> string
    
    Returns the label at column index.
 
    C++ signature :
        std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
getRow(...)
getRow( (NTupleInternal)arg1, (int)arg2) -> object :
    getRow ( index ) -> list
    
    Returns the index row as list floats.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
setIntervalCount(...)
setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
    setIntervalCount ( count ) -> None
    
    Sets the interval count between updates to the observers.
 
    C++ signature :
        void setIntervalCount(hippodraw::NTuple {lvalue},int)
setIntervalEnabled(...)
setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
    setIntervalEnable ( Boolean ) -> None
    
    Sets the interval counting on or off
 
    C++ signature :
        void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
setLabels(...)
setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
    setLabels ( sequence ) -> None
    
    Sets the labels of the columns from the list of strings.  If the
    NTuple is empty, then also sets the number of columns to be the
    size of the list.   If the number of columns has already been
    set, the the size of the list should be the same, otherwise
    a RuntimeError exception is thrown.
 
    C++ signature :
        void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)

Data and other attributes defined here:
__instance_size__ = 116

Methods inherited from DataSource:
clear(...)
clear( (DataSource)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::DataSource {lvalue})
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
replaceColumn(...)
replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
    replaceColumn ( label, list ) -> None
    
    Replaces the column of data by abel.
 
    C++ signature :
        void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from DataSource:
columns
rows

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class NumArrayTuple(DataSource)
    Interface to numarray Python extension module.
 
 
Method resolution order:
NumArrayTuple
DataSource
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
    Creates an empty NumArrayTuple
 
    C++ signature :
        void __init__(_object*)
__reduce__ = (...)
addColumn(...)
addColumn( (NumArrayTuple)arg1, (str)arg2, (object)arg3) -> int :
    Adds the array as a new column with label
 
    C++ signature :
        int addColumn(hippodraw::NumArrayTuple {lvalue},std::string,boost::python::numeric::array)
getLabel(...)
getLabel( (NumArrayTuple)arg1, (int)arg2) -> str :
 
    C++ signature :
        std::string getLabel(hippodraw::NumArrayTuple {lvalue},unsigned int)
notifyObservers(...)
notifyObservers( (NumArrayTuple)arg1) -> None :
    Sends update message to all observers.
 
    C++ signature :
        void notifyObservers(hippodraw::NumArrayTuple {lvalue})
replaceColumn(...)
replaceColumn( (NumArrayTuple)arg1, (int)arg2, (object)arg3) -> None :
    Replaces existing column with new array
    Args:
         index
         numarray
 
    C++ signature :
        void replaceColumn(hippodraw::NumArrayTuple {lvalue},unsigned int,boost::python::numeric::array)
 
replaceColumn( (NumArrayTuple)arg1, (str)arg2, (object)arg3) -> None :
    Replaces existing column with new array
    Args:
         label
         numarray
 
    C++ signature :
        void replaceColumn(hippodraw::NumArrayTuple {lvalue},std::string,boost::python::numeric::array)
setLabels(...)
setLabels( (NumArrayTuple)arg1, (object)[label, ...]) -> None :
    Sets the labels of the columns.
 
    C++ signature :
        void setLabels(hippodraw::NumArrayTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)

Data and other attributes defined here:
__instance_size__ = 104

Methods inherited from DataSource:
clear(...)
clear( (DataSource)arg1) -> None :
    clear () -> None
    
    Clears the data elements of the DataSource.   That is, remove
    all the rows while keeping the column labels.
 
    C++ signature :
        void clear(hippodraw::DataSource {lvalue})
getColumn(...)
getColumn( (DataSource)arg1, (int)arg2) -> object :
    getColumn ( label ) -> list
    getColumn ( index ) -> list
    
    Get a column by its label or index.   Returns copy of the
    contents.
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
 
getColumn( (DataSource)arg1, (str)arg2) -> object :
 
    C++ signature :
        std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
getLabels(...)
getLabels( (DataSource)arg1) -> object :
    getLabels () -> list
    
    Returns list of column labels.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
getTitle(...)
getTitle( (DataSource)arg1) -> str :
    getTitle () -> string
    
    Returns the title of the ntuple.
 
    C++ signature :
        std::string getTitle(hippodraw::DataSource {lvalue})
setName(...)
setName( (DataSource)arg1, (str)arg2) -> None :
    setName ( string ) -> None
    
    Sets the name of the ntuple.   The name should be a unique
    string withing a running application.   It may appear in the
    Inspector.
 
    C++ signature :
        void setName(hippodraw::DataSource {lvalue},std::string)
setTitle(...)
setTitle( (DataSource)arg1, (str)arg2) -> None :
    setTitle ( string ) -> None
    
    Sets the title of the ntuple.  The title by default appears at
    the top of a Display.
 
    C++ signature :
        void setTitle(hippodraw::DataSource {lvalue},std::string)

Data descriptors inherited from DataSource:
columns
rows

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Observable(Boost.Python.instance)
    The base class for classes that can be target of an Observer
object.
 
 
Method resolution order:
Observable
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
__reduce__ = (...)

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Observer(Boost.Python.instance)
    The base class for classes that can be targets of Observable
update messages.
 
 
Method resolution order:
Observer
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class PointRepFactory(FactoryPointRep)
    A factory for creating object whose class derive from PointRep.
 
 
Method resolution order:
PointRepFactory
FactoryPointRep
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
create(...)
create( (PointRepFactory)arg1, (str)arg2) -> RepBase :
    create ( string ) -> PointRep
    
    Returns a PointRep object of type named in string.
 
    C++ signature :
        hippodraw::RepBasecreate(hippodraw::PointRepFactory {lvalue},std::string)
names(...)
names( (PointRepFactory)arg1) -> object :
    names () -> sequence
    
    Returns the names of available PointRep classes.
 
    C++ signature :
        std::vector<std::string, std::allocator<std::string> > names(hippodraw::PointRepFactory {lvalue})

Static methods defined here:
instance(...)
instance() -> PointRepFactory :
    instance () -> PointRepFactory
    
    Returns the instance of the PointRepFactory.
 
    C++ signature :
        hippodraw::PointRepFactoryinstance()

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class RepBase(Boost.Python.instance)
    The base class for  point and text representations.
See PointRepFactory for creating objects of this type.
 
 
Method resolution order:
RepBase
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class StatedFCN(FCNBase)
    This a base class for objective function used in fitting that
maintains the state of the function's parameters.
 
 
Method resolution order:
StatedFCN
FCNBase
Boost.Python.instance
__builtin__.object

Methods defined here:
__reduce__ = (...)
degreesOfFreedom(...)
degreesOfFreedom( (StatedFCN)arg1) -> int :
    degreesOfFreedom () -> value
    
    Returns the degrees of freedom as integer.
 
    C++ signature :
        int degreesOfFreedom(hippodraw::StatedFCN {lvalue})
objectiveValue(...)
objectiveValue( (StatedFCN)arg1) -> float :
    objectiveValue () -> value
    
    Returns the objective value.   For example, the objective
    might be the Chi-Squared when derived class returns it as
    its objective value.
 
    C++ signature :
        double objectiveValue(hippodraw::StatedFCN {lvalue})
setDataSource(...)
setDataSource( (StatedFCN)arg1, (DataSource)arg2) -> None :
 
    C++ signature :
        void setDataSource(hippodraw::StatedFCN {lvalue},hippodraw::DataSource const*)
 
setDataSource( (StatedFCN)arg1, (DataSource)arg2, (int)arg3, (object)arg4) -> None :
    setDataSource ( DataSource ) -> None
    setDataSource ( DataSource, value, sequence ) -> None
    
    The first form sets the data source with default indexes.  The
    second form takes in addition the dimensionality of the
    coordinate and a column indexes from the sequence.
 
    C++ signature :
        void setDataSource(hippodraw::StatedFCN {lvalue},hippodraw::DataSource const*,int,std::vector<int, std::allocator<int> >)
setFunction(...)
setFunction( (StatedFCN)arg1, (FunctionBase)arg2) -> None :
    setFunction ( FunctionBase ) -> None
    
    Sets the model function.
 
    C++ signature :
        void setFunction(hippodraw::StatedFCN {lvalue},hippodraw::FunctionBase*)
setUseErrors(...)
setUseErrors( (StatedFCN)arg1, (bool)arg2) -> bool :
    setUseErrors ( Boolean ) -> None
    
    Sets the FCN to use errors on the data source if they exist.
 
    C++ signature :
        bool setUseErrors(hippodraw::StatedFCN {lvalue},bool)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0xf6e1d788>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Symbol(Boost.Python.enum)
    
Method resolution order:
Symbol
Boost.Python.enum
__builtin__.int
__builtin__.object

Data and other attributes defined here:
filledcircle = hippo.Symbol.filledcircle
filledsquare = hippo.Symbol.filledsquare
filledtriangle = hippo.Symbol.filledtriangle
invisible = hippo.Symbol.invisible
opencircle = hippo.Symbol.opencircle
opensquare = hippo.Symbol.opensquare
opentriangle = hippo.Symbol.opentriangle
plus = hippo.Symbol.plus
times = hippo.Symbol.times
values = {0: hippo.Symbol.opensquare, 1: hippo.Symbol.filledsquare, 2: hippo.Symbol.plus, 3: hippo.Symbol.times, 4: hippo.Symbol.opentriangle, 5: hippo.Symbol.filledtriangle, 6: hippo.Symbol.opencircle, 7: hippo.Symbol.filledcircle, 8: hippo.Symbol.invisible}

Methods inherited from Boost.Python.enum:
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data descriptors inherited from Boost.Python.enum:
name

Methods inherited from __builtin__.int:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__trunc__(...)
Truncating an Integral returns itself.
__xor__(...)
x.__xor__(y) <==> x^y
conjugate(...)
Returns self, the complex conjugate of any int.

Data descriptors inherited from __builtin__.int:
denominator
the denominator of a rational number in lowest terms
imag
the imaginary part of a complex number
numerator
the numerator of a rational number in lowest terms
real
the real part of a complex number

Data and other attributes inherited from __builtin__.int:
__new__ = <built-in method __new__ of type object at 0xf7f5d8e0>
T.__new__(S, ...) -> a new object with type S, a subtype of T