python-csoundac 1:6.10.0~dfsg-1 / usr / lib / python2.7 / dist-packages / CsoundAC.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_CsoundAC')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_CsoundAC')
    _CsoundAC = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_CsoundAC', [dirname(__file__)])
        except ImportError:
            import _CsoundAC
            return _CsoundAC
        try:
            _mod = imp.load_module('_CsoundAC', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _CsoundAC = swig_import_helper()
    del swig_import_helper
else:
    import _CsoundAC
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CsoundAC.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _CsoundAC.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _CsoundAC.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _CsoundAC.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _CsoundAC.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _CsoundAC.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _CsoundAC.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _CsoundAC.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _CsoundAC.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _CsoundAC.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _CsoundAC.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _CsoundAC.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _CsoundAC.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _CsoundAC.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _CsoundAC.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _CsoundAC.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _CsoundAC.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _CsoundAC.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class DoubleVector(_object):
    """Proxy of C++ std::vector<(double)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DoubleVector self) -> SwigPyIterator"""
        return _CsoundAC.DoubleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(DoubleVector self) -> bool"""
        return _CsoundAC.DoubleVector___nonzero__(self)


    def __bool__(self):
        """__bool__(DoubleVector self) -> bool"""
        return _CsoundAC.DoubleVector___bool__(self)


    def __len__(self):
        """__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return _CsoundAC.DoubleVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"""
        return _CsoundAC.DoubleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)
        """
        return _CsoundAC.DoubleVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _CsoundAC.DoubleVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(DoubleVector self, std::vector< double >::difference_type i)
        __delitem__(DoubleVector self, PySliceObject * slice)
        """
        return _CsoundAC.DoubleVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(DoubleVector self, PySliceObject * slice) -> DoubleVector
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _CsoundAC.DoubleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(DoubleVector self, PySliceObject * slice, DoubleVector v)
        __setitem__(DoubleVector self, PySliceObject * slice)
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _CsoundAC.DoubleVector___setitem__(self, *args)


    def pop(self):
        """pop(DoubleVector self) -> std::vector< double >::value_type"""
        return _CsoundAC.DoubleVector_pop(self)


    def append(self, x):
        """append(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _CsoundAC.DoubleVector_append(self, x)


    def empty(self):
        """empty(DoubleVector self) -> bool"""
        return _CsoundAC.DoubleVector_empty(self)


    def size(self):
        """size(DoubleVector self) -> std::vector< double >::size_type"""
        return _CsoundAC.DoubleVector_size(self)


    def swap(self, v):
        """swap(DoubleVector self, DoubleVector v)"""
        return _CsoundAC.DoubleVector_swap(self, v)


    def begin(self):
        """begin(DoubleVector self) -> std::vector< double >::iterator"""
        return _CsoundAC.DoubleVector_begin(self)


    def end(self):
        """end(DoubleVector self) -> std::vector< double >::iterator"""
        return _CsoundAC.DoubleVector_end(self)


    def rbegin(self):
        """rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _CsoundAC.DoubleVector_rbegin(self)


    def rend(self):
        """rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _CsoundAC.DoubleVector_rend(self)


    def clear(self):
        """clear(DoubleVector self)"""
        return _CsoundAC.DoubleVector_clear(self)


    def get_allocator(self):
        """get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return _CsoundAC.DoubleVector_get_allocator(self)


    def pop_back(self):
        """pop_back(DoubleVector self)"""
        return _CsoundAC.DoubleVector_pop_back(self)


    def erase(self, *args):
        """
        erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _CsoundAC.DoubleVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> DoubleVector
        __init__(std::vector<(double)> self, DoubleVector arg2) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        this = _CsoundAC.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _CsoundAC.DoubleVector_push_back(self, x)


    def front(self):
        """front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _CsoundAC.DoubleVector_front(self)


    def back(self):
        """back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _CsoundAC.DoubleVector_back(self)


    def assign(self, n, x):
        """assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _CsoundAC.DoubleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(DoubleVector self, std::vector< double >::size_type new_size)
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _CsoundAC.DoubleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _CsoundAC.DoubleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(DoubleVector self, std::vector< double >::size_type n)"""
        return _CsoundAC.DoubleVector_reserve(self, n)


    def capacity(self):
        """capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _CsoundAC.DoubleVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _CsoundAC.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class Conversions(_object):
    """Proxy of C++ csound::Conversions class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Conversions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Conversions, name)
    __repr__ = _swig_repr

    def getPI():
        """getPI() -> double"""
        return _CsoundAC.Conversions_getPI()

    getPI = staticmethod(getPI)

    def get2PI():
        """get2PI() -> double"""
        return _CsoundAC.Conversions_get2PI()

    get2PI = staticmethod(get2PI)

    def getMiddleCHz():
        """getMiddleCHz() -> double"""
        return _CsoundAC.Conversions_getMiddleCHz()

    getMiddleCHz = staticmethod(getMiddleCHz)

    def getNORM_7():
        """getNORM_7() -> double"""
        return _CsoundAC.Conversions_getNORM_7()

    getNORM_7 = staticmethod(getNORM_7)

    def initialize():
        """initialize() -> bool"""
        return _CsoundAC.Conversions_initialize()

    initialize = staticmethod(initialize)

    def getSampleSize():
        """getSampleSize() -> int"""
        return _CsoundAC.Conversions_getSampleSize()

    getSampleSize = staticmethod(getSampleSize)

    def getMaximumAmplitude(size):
        """getMaximumAmplitude(int size) -> double"""
        return _CsoundAC.Conversions_getMaximumAmplitude(size)

    getMaximumAmplitude = staticmethod(getMaximumAmplitude)

    def getMaximumDynamicRange():
        """getMaximumDynamicRange() -> double"""
        return _CsoundAC.Conversions_getMaximumDynamicRange()

    getMaximumDynamicRange = staticmethod(getMaximumDynamicRange)

    def amplitudeToDecibels(amplitude):
        """amplitudeToDecibels(double amplitude) -> double"""
        return _CsoundAC.Conversions_amplitudeToDecibels(amplitude)

    amplitudeToDecibels = staticmethod(amplitudeToDecibels)

    def amplitudeToGain(Amplitude):
        """amplitudeToGain(double Amplitude) -> double"""
        return _CsoundAC.Conversions_amplitudeToGain(Amplitude)

    amplitudeToGain = staticmethod(amplitudeToGain)

    def decibelsToAmplitude(decibels):
        """decibelsToAmplitude(double decibels) -> double"""
        return _CsoundAC.Conversions_decibelsToAmplitude(decibels)

    decibelsToAmplitude = staticmethod(decibelsToAmplitude)

    def decibelsToMidi(decibels):
        """decibelsToMidi(double decibels) -> double"""
        return _CsoundAC.Conversions_decibelsToMidi(decibels)

    decibelsToMidi = staticmethod(decibelsToMidi)

    def gainToAmplitude(Gain):
        """gainToAmplitude(double Gain) -> double"""
        return _CsoundAC.Conversions_gainToAmplitude(Gain)

    gainToAmplitude = staticmethod(gainToAmplitude)

    def midiToDecibels(Midi):
        """midiToDecibels(double Midi) -> double"""
        return _CsoundAC.Conversions_midiToDecibels(Midi)

    midiToDecibels = staticmethod(midiToDecibels)

    def midiToAmplitude(Midi):
        """midiToAmplitude(double Midi) -> double"""
        return _CsoundAC.Conversions_midiToAmplitude(Midi)

    midiToAmplitude = staticmethod(midiToAmplitude)

    def amplitudeToMidi(Amplitude):
        """amplitudeToMidi(double Amplitude) -> double"""
        return _CsoundAC.Conversions_amplitudeToMidi(Amplitude)

    amplitudeToMidi = staticmethod(amplitudeToMidi)

    def midiToGain(Midi):
        """midiToGain(double Midi) -> double"""
        return _CsoundAC.Conversions_midiToGain(Midi)

    midiToGain = staticmethod(midiToGain)

    def leftPan(x):
        """leftPan(double x) -> double"""
        return _CsoundAC.Conversions_leftPan(x)

    leftPan = staticmethod(leftPan)

    def round(value):
        """round(double value) -> double"""
        return _CsoundAC.Conversions_round(value)

    round = staticmethod(round)

    def temper(octave, tonesPerOctave):
        """temper(double octave, double tonesPerOctave) -> double"""
        return _CsoundAC.Conversions_temper(octave, tonesPerOctave)

    temper = staticmethod(temper)

    def phaseToTableLengths(Phase, TableSampleCount):
        """phaseToTableLengths(double Phase, double TableSampleCount) -> double"""
        return _CsoundAC.Conversions_phaseToTableLengths(Phase, TableSampleCount)

    phaseToTableLengths = staticmethod(phaseToTableLengths)

    def hzToMidi(Hz, rounded):
        """hzToMidi(double Hz, bool rounded) -> double"""
        return _CsoundAC.Conversions_hzToMidi(Hz, rounded)

    hzToMidi = staticmethod(hzToMidi)

    def hzToOctave(Hz):
        """hzToOctave(double Hz) -> double"""
        return _CsoundAC.Conversions_hzToOctave(Hz)

    hzToOctave = staticmethod(hzToOctave)

    def hzToSamplingIncrement(Hz, SR, SamplesPerCycle):
        """hzToSamplingIncrement(double Hz, double SR, double SamplesPerCycle) -> double"""
        return _CsoundAC.Conversions_hzToSamplingIncrement(Hz, SR, SamplesPerCycle)

    hzToSamplingIncrement = staticmethod(hzToSamplingIncrement)

    def midiToHz(Midi):
        """midiToHz(double Midi) -> double"""
        return _CsoundAC.Conversions_midiToHz(Midi)

    midiToHz = staticmethod(midiToHz)

    def midiToOctave(Midi):
        """midiToOctave(double Midi) -> double"""
        return _CsoundAC.Conversions_midiToOctave(Midi)

    midiToOctave = staticmethod(midiToOctave)

    def midiToSamplingIncrement(Midi, SR, SamplesPerCycle):
        """midiToSamplingIncrement(double Midi, double SR, double SamplesPerCycle) -> double"""
        return _CsoundAC.Conversions_midiToSamplingIncrement(Midi, SR, SamplesPerCycle)

    midiToSamplingIncrement = staticmethod(midiToSamplingIncrement)

    def octaveToHz(Octave):
        """octaveToHz(double Octave) -> double"""
        return _CsoundAC.Conversions_octaveToHz(Octave)

    octaveToHz = staticmethod(octaveToHz)

    def octaveToMidi(Octave, rounded):
        """octaveToMidi(double Octave, bool rounded) -> double"""
        return _CsoundAC.Conversions_octaveToMidi(Octave, rounded)

    octaveToMidi = staticmethod(octaveToMidi)

    def octaveToSamplingIncrement(Octave, SR, SamplesPerCycle):
        """octaveToSamplingIncrement(double Octave, double SR, double SamplesPerCycle) -> double"""
        return _CsoundAC.Conversions_octaveToSamplingIncrement(Octave, SR, SamplesPerCycle)

    octaveToSamplingIncrement = staticmethod(octaveToSamplingIncrement)

    def rightPan(x):
        """rightPan(double x) -> double"""
        return _CsoundAC.Conversions_rightPan(x)

    rightPan = staticmethod(rightPan)

    def swapInt(Source):
        """swapInt(int Source) -> int"""
        return _CsoundAC.Conversions_swapInt(Source)

    swapInt = staticmethod(swapInt)

    def swapShort(Source):
        """swapShort(short Source) -> short"""
        return _CsoundAC.Conversions_swapShort(Source)

    swapShort = staticmethod(swapShort)

    def stringToBool(value, default_=False):
        """
        stringToBool(std::string value, bool default_=False) -> bool
        stringToBool(std::string value) -> bool
        """
        return _CsoundAC.Conversions_stringToBool(value, default_)

    stringToBool = staticmethod(stringToBool)

    def boolToString(value):
        """boolToString(bool value) -> std::string"""
        return _CsoundAC.Conversions_boolToString(value)

    boolToString = staticmethod(boolToString)

    def stringToInt(value, default_=0):
        """
        stringToInt(std::string value, int default_=0) -> int
        stringToInt(std::string value) -> int
        """
        return _CsoundAC.Conversions_stringToInt(value, default_)

    stringToInt = staticmethod(stringToInt)

    def intToString(value):
        """intToString(int value) -> std::string"""
        return _CsoundAC.Conversions_intToString(value)

    intToString = staticmethod(intToString)

    def stringToDouble(value, default_=0.0):
        """
        stringToDouble(std::string value, double default_=0.0) -> double
        stringToDouble(std::string value) -> double
        """
        return _CsoundAC.Conversions_stringToDouble(value, default_)

    stringToDouble = staticmethod(stringToDouble)

    def doubleToString(value):
        """doubleToString(double value) -> std::string"""
        return _CsoundAC.Conversions_doubleToString(value)

    doubleToString = staticmethod(doubleToString)

    def stringToVector(text, vector):
        """stringToVector(std::string const & text, DoubleVector vector)"""
        return _CsoundAC.Conversions_stringToVector(text, vector)

    stringToVector = staticmethod(stringToVector)

    def midiToPitchClass(midiKey):
        """midiToPitchClass(double midiKey) -> double"""
        return _CsoundAC.Conversions_midiToPitchClass(midiKey)

    midiToPitchClass = staticmethod(midiToPitchClass)

    def pitchClassSetToMidi(pitchClassSet):
        """pitchClassSetToMidi(double pitchClassSet) -> double"""
        return _CsoundAC.Conversions_pitchClassSetToMidi(pitchClassSet)

    pitchClassSetToMidi = staticmethod(pitchClassSetToMidi)

    def midiToPitchClassSet(midiKey):
        """midiToPitchClassSet(double midiKey) -> double"""
        return _CsoundAC.Conversions_midiToPitchClassSet(midiKey)

    midiToPitchClassSet = staticmethod(midiToPitchClassSet)

    def pitchClassToMidi(pitchClass):
        """pitchClassToMidi(double pitchClass) -> double"""
        return _CsoundAC.Conversions_pitchClassToMidi(pitchClass)

    pitchClassToMidi = staticmethod(pitchClassToMidi)

    def findClosestPitchClass(M, pitchClass, tones=12.0):
        """
        findClosestPitchClass(double M, double pitchClass, double tones=12.0) -> double
        findClosestPitchClass(double M, double pitchClass) -> double
        """
        return _CsoundAC.Conversions_findClosestPitchClass(M, pitchClass, tones)

    findClosestPitchClass = staticmethod(findClosestPitchClass)

    def midiToRoundedOctave(midiKey):
        """midiToRoundedOctave(double midiKey) -> double"""
        return _CsoundAC.Conversions_midiToRoundedOctave(midiKey)

    midiToRoundedOctave = staticmethod(midiToRoundedOctave)

    def trim(value):
        """trim(std::string & value) -> std::string &"""
        return _CsoundAC.Conversions_trim(value)

    trim = staticmethod(trim)

    def trimQuotes(value):
        """trimQuotes(std::string & value) -> std::string &"""
        return _CsoundAC.Conversions_trimQuotes(value)

    trimQuotes = staticmethod(trimQuotes)

    def modulus(a, b):
        """modulus(double a, double b) -> double"""
        return _CsoundAC.Conversions_modulus(a, b)

    modulus = staticmethod(modulus)

    def nameToPitches(name):
        """nameToPitches(std::string name) -> DoubleVector"""
        return _CsoundAC.Conversions_nameToPitches(name)

    nameToPitches = staticmethod(nameToPitches)

    def nameToM(name):
        """nameToM(std::string name) -> double"""
        return _CsoundAC.Conversions_nameToM(name)

    nameToM = staticmethod(nameToM)

    def mToName(pitchClassSet):
        """mToName(double pitchClassSet) -> std::string"""
        return _CsoundAC.Conversions_mToName(pitchClassSet)

    mToName = staticmethod(mToName)

    def dupstr(string):
        """dupstr(char const * string) -> char *"""
        return _CsoundAC.Conversions_dupstr(string)

    dupstr = staticmethod(dupstr)

    def gainToDb(inputDb, gain, odbfs=False):
        """
        gainToDb(double inputDb, double gain, bool odbfs=False) -> double
        gainToDb(double inputDb, double gain) -> double
        """
        return _CsoundAC.Conversions_gainToDb(inputDb, gain, odbfs)

    gainToDb = staticmethod(gainToDb)

    def EPSILON():
        """EPSILON() -> double"""
        return _CsoundAC.Conversions_EPSILON()

    EPSILON = staticmethod(EPSILON)

    def epsilonFactor():
        """epsilonFactor() -> double &"""
        return _CsoundAC.Conversions_epsilonFactor()

    epsilonFactor = staticmethod(epsilonFactor)

    def eq_epsilon(a, b):
        """eq_epsilon(double a, double b) -> bool"""
        return _CsoundAC.Conversions_eq_epsilon(a, b)

    eq_epsilon = staticmethod(eq_epsilon)

    def gt_epsilon(a, b):
        """gt_epsilon(double a, double b) -> bool"""
        return _CsoundAC.Conversions_gt_epsilon(a, b)

    gt_epsilon = staticmethod(gt_epsilon)

    def lt_epsilon(a, b):
        """lt_epsilon(double a, double b) -> bool"""
        return _CsoundAC.Conversions_lt_epsilon(a, b)

    lt_epsilon = staticmethod(lt_epsilon)

    def ge_epsilon(a, b):
        """ge_epsilon(double a, double b) -> bool"""
        return _CsoundAC.Conversions_ge_epsilon(a, b)

    ge_epsilon = staticmethod(ge_epsilon)

    def le_epsilon(a, b):
        """le_epsilon(double a, double b) -> bool"""
        return _CsoundAC.Conversions_le_epsilon(a, b)

    le_epsilon = staticmethod(le_epsilon)

    def __init__(self):
        """__init__(csound::Conversions self) -> Conversions"""
        this = _CsoundAC.new_Conversions()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Conversions
    __del__ = lambda self: None
Conversions_swigregister = _CsoundAC.Conversions_swigregister
Conversions_swigregister(Conversions)

def Conversions_getPI():
    """Conversions_getPI() -> double"""
    return _CsoundAC.Conversions_getPI()

def Conversions_get2PI():
    """Conversions_get2PI() -> double"""
    return _CsoundAC.Conversions_get2PI()

def Conversions_getMiddleCHz():
    """Conversions_getMiddleCHz() -> double"""
    return _CsoundAC.Conversions_getMiddleCHz()

def Conversions_getNORM_7():
    """Conversions_getNORM_7() -> double"""
    return _CsoundAC.Conversions_getNORM_7()

def Conversions_initialize():
    """Conversions_initialize() -> bool"""
    return _CsoundAC.Conversions_initialize()

def Conversions_getSampleSize():
    """Conversions_getSampleSize() -> int"""
    return _CsoundAC.Conversions_getSampleSize()

def Conversions_getMaximumAmplitude(size):
    """Conversions_getMaximumAmplitude(int size) -> double"""
    return _CsoundAC.Conversions_getMaximumAmplitude(size)

def Conversions_getMaximumDynamicRange():
    """Conversions_getMaximumDynamicRange() -> double"""
    return _CsoundAC.Conversions_getMaximumDynamicRange()

def Conversions_amplitudeToDecibels(amplitude):
    """Conversions_amplitudeToDecibels(double amplitude) -> double"""
    return _CsoundAC.Conversions_amplitudeToDecibels(amplitude)

def Conversions_amplitudeToGain(Amplitude):
    """Conversions_amplitudeToGain(double Amplitude) -> double"""
    return _CsoundAC.Conversions_amplitudeToGain(Amplitude)

def Conversions_decibelsToAmplitude(decibels):
    """Conversions_decibelsToAmplitude(double decibels) -> double"""
    return _CsoundAC.Conversions_decibelsToAmplitude(decibels)

def Conversions_decibelsToMidi(decibels):
    """Conversions_decibelsToMidi(double decibels) -> double"""
    return _CsoundAC.Conversions_decibelsToMidi(decibels)

def Conversions_gainToAmplitude(Gain):
    """Conversions_gainToAmplitude(double Gain) -> double"""
    return _CsoundAC.Conversions_gainToAmplitude(Gain)

def Conversions_midiToDecibels(Midi):
    """Conversions_midiToDecibels(double Midi) -> double"""
    return _CsoundAC.Conversions_midiToDecibels(Midi)

def Conversions_midiToAmplitude(Midi):
    """Conversions_midiToAmplitude(double Midi) -> double"""
    return _CsoundAC.Conversions_midiToAmplitude(Midi)

def Conversions_amplitudeToMidi(Amplitude):
    """Conversions_amplitudeToMidi(double Amplitude) -> double"""
    return _CsoundAC.Conversions_amplitudeToMidi(Amplitude)

def Conversions_midiToGain(Midi):
    """Conversions_midiToGain(double Midi) -> double"""
    return _CsoundAC.Conversions_midiToGain(Midi)

def Conversions_leftPan(x):
    """Conversions_leftPan(double x) -> double"""
    return _CsoundAC.Conversions_leftPan(x)

def Conversions_round(value):
    """Conversions_round(double value) -> double"""
    return _CsoundAC.Conversions_round(value)

def Conversions_temper(octave, tonesPerOctave):
    """Conversions_temper(double octave, double tonesPerOctave) -> double"""
    return _CsoundAC.Conversions_temper(octave, tonesPerOctave)

def Conversions_phaseToTableLengths(Phase, TableSampleCount):
    """Conversions_phaseToTableLengths(double Phase, double TableSampleCount) -> double"""
    return _CsoundAC.Conversions_phaseToTableLengths(Phase, TableSampleCount)

def Conversions_hzToMidi(Hz, rounded):
    """Conversions_hzToMidi(double Hz, bool rounded) -> double"""
    return _CsoundAC.Conversions_hzToMidi(Hz, rounded)

def Conversions_hzToOctave(Hz):
    """Conversions_hzToOctave(double Hz) -> double"""
    return _CsoundAC.Conversions_hzToOctave(Hz)

def Conversions_hzToSamplingIncrement(Hz, SR, SamplesPerCycle):
    """Conversions_hzToSamplingIncrement(double Hz, double SR, double SamplesPerCycle) -> double"""
    return _CsoundAC.Conversions_hzToSamplingIncrement(Hz, SR, SamplesPerCycle)

def Conversions_midiToHz(Midi):
    """Conversions_midiToHz(double Midi) -> double"""
    return _CsoundAC.Conversions_midiToHz(Midi)

def Conversions_midiToOctave(Midi):
    """Conversions_midiToOctave(double Midi) -> double"""
    return _CsoundAC.Conversions_midiToOctave(Midi)

def Conversions_midiToSamplingIncrement(Midi, SR, SamplesPerCycle):
    """Conversions_midiToSamplingIncrement(double Midi, double SR, double SamplesPerCycle) -> double"""
    return _CsoundAC.Conversions_midiToSamplingIncrement(Midi, SR, SamplesPerCycle)

def Conversions_octaveToHz(Octave):
    """Conversions_octaveToHz(double Octave) -> double"""
    return _CsoundAC.Conversions_octaveToHz(Octave)

def Conversions_octaveToMidi(Octave, rounded):
    """Conversions_octaveToMidi(double Octave, bool rounded) -> double"""
    return _CsoundAC.Conversions_octaveToMidi(Octave, rounded)

def Conversions_octaveToSamplingIncrement(Octave, SR, SamplesPerCycle):
    """Conversions_octaveToSamplingIncrement(double Octave, double SR, double SamplesPerCycle) -> double"""
    return _CsoundAC.Conversions_octaveToSamplingIncrement(Octave, SR, SamplesPerCycle)

def Conversions_rightPan(x):
    """Conversions_rightPan(double x) -> double"""
    return _CsoundAC.Conversions_rightPan(x)

def Conversions_swapInt(Source):
    """Conversions_swapInt(int Source) -> int"""
    return _CsoundAC.Conversions_swapInt(Source)

def Conversions_swapShort(Source):
    """Conversions_swapShort(short Source) -> short"""
    return _CsoundAC.Conversions_swapShort(Source)

def Conversions_stringToBool(value, default_=False):
    """
    stringToBool(std::string value, bool default_=False) -> bool
    Conversions_stringToBool(std::string value) -> bool
    """
    return _CsoundAC.Conversions_stringToBool(value, default_)

def Conversions_boolToString(value):
    """Conversions_boolToString(bool value) -> std::string"""
    return _CsoundAC.Conversions_boolToString(value)

def Conversions_stringToInt(value, default_=0):
    """
    stringToInt(std::string value, int default_=0) -> int
    Conversions_stringToInt(std::string value) -> int
    """
    return _CsoundAC.Conversions_stringToInt(value, default_)

def Conversions_intToString(value):
    """Conversions_intToString(int value) -> std::string"""
    return _CsoundAC.Conversions_intToString(value)

def Conversions_stringToDouble(value, default_=0.0):
    """
    stringToDouble(std::string value, double default_=0.0) -> double
    Conversions_stringToDouble(std::string value) -> double
    """
    return _CsoundAC.Conversions_stringToDouble(value, default_)

def Conversions_doubleToString(value):
    """Conversions_doubleToString(double value) -> std::string"""
    return _CsoundAC.Conversions_doubleToString(value)

def Conversions_stringToVector(text, vector):
    """Conversions_stringToVector(std::string const & text, DoubleVector vector)"""
    return _CsoundAC.Conversions_stringToVector(text, vector)

def Conversions_midiToPitchClass(midiKey):
    """Conversions_midiToPitchClass(double midiKey) -> double"""
    return _CsoundAC.Conversions_midiToPitchClass(midiKey)

def Conversions_pitchClassSetToMidi(pitchClassSet):
    """Conversions_pitchClassSetToMidi(double pitchClassSet) -> double"""
    return _CsoundAC.Conversions_pitchClassSetToMidi(pitchClassSet)

def Conversions_midiToPitchClassSet(midiKey):
    """Conversions_midiToPitchClassSet(double midiKey) -> double"""
    return _CsoundAC.Conversions_midiToPitchClassSet(midiKey)

def Conversions_pitchClassToMidi(pitchClass):
    """Conversions_pitchClassToMidi(double pitchClass) -> double"""
    return _CsoundAC.Conversions_pitchClassToMidi(pitchClass)

def Conversions_findClosestPitchClass(M, pitchClass, tones=12.0):
    """
    findClosestPitchClass(double M, double pitchClass, double tones=12.0) -> double
    Conversions_findClosestPitchClass(double M, double pitchClass) -> double
    """
    return _CsoundAC.Conversions_findClosestPitchClass(M, pitchClass, tones)

def Conversions_midiToRoundedOctave(midiKey):
    """Conversions_midiToRoundedOctave(double midiKey) -> double"""
    return _CsoundAC.Conversions_midiToRoundedOctave(midiKey)

def Conversions_trim(value):
    """Conversions_trim(std::string & value) -> std::string &"""
    return _CsoundAC.Conversions_trim(value)

def Conversions_trimQuotes(value):
    """Conversions_trimQuotes(std::string & value) -> std::string &"""
    return _CsoundAC.Conversions_trimQuotes(value)

def Conversions_modulus(a, b):
    """Conversions_modulus(double a, double b) -> double"""
    return _CsoundAC.Conversions_modulus(a, b)

def Conversions_nameToPitches(name):
    """Conversions_nameToPitches(std::string name) -> DoubleVector"""
    return _CsoundAC.Conversions_nameToPitches(name)

def Conversions_nameToM(name):
    """Conversions_nameToM(std::string name) -> double"""
    return _CsoundAC.Conversions_nameToM(name)

def Conversions_mToName(pitchClassSet):
    """Conversions_mToName(double pitchClassSet) -> std::string"""
    return _CsoundAC.Conversions_mToName(pitchClassSet)

def Conversions_dupstr(string):
    """Conversions_dupstr(char const * string) -> char *"""
    return _CsoundAC.Conversions_dupstr(string)

def Conversions_gainToDb(inputDb, gain, odbfs=False):
    """
    gainToDb(double inputDb, double gain, bool odbfs=False) -> double
    Conversions_gainToDb(double inputDb, double gain) -> double
    """
    return _CsoundAC.Conversions_gainToDb(inputDb, gain, odbfs)

def Conversions_EPSILON():
    """Conversions_EPSILON() -> double"""
    return _CsoundAC.Conversions_EPSILON()

def Conversions_epsilonFactor():
    """Conversions_epsilonFactor() -> double &"""
    return _CsoundAC.Conversions_epsilonFactor()

def Conversions_eq_epsilon(a, b):
    """Conversions_eq_epsilon(double a, double b) -> bool"""
    return _CsoundAC.Conversions_eq_epsilon(a, b)

def Conversions_gt_epsilon(a, b):
    """Conversions_gt_epsilon(double a, double b) -> bool"""
    return _CsoundAC.Conversions_gt_epsilon(a, b)

def Conversions_lt_epsilon(a, b):
    """Conversions_lt_epsilon(double a, double b) -> bool"""
    return _CsoundAC.Conversions_lt_epsilon(a, b)

def Conversions_ge_epsilon(a, b):
    """Conversions_ge_epsilon(double a, double b) -> bool"""
    return _CsoundAC.Conversions_ge_epsilon(a, b)

def Conversions_le_epsilon(a, b):
    """Conversions_le_epsilon(double a, double b) -> bool"""
    return _CsoundAC.Conversions_le_epsilon(a, b)

class Logger(_object):
    """Proxy of C++ csound::Logger class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Logger, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Logger self) -> Logger"""
        this = _CsoundAC.new_Logger()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Logger
    __del__ = lambda self: None

    def write(self, text):
        """write(Logger self, char const * text)"""
        return _CsoundAC.Logger_write(self, text)

Logger_swigregister = _CsoundAC.Logger_swigregister
Logger_swigregister(Logger)

class System(_object):
    """Proxy of C++ csound::System class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, System, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, System, name)
    __repr__ = _swig_repr
    ERROR_LEVEL = _CsoundAC.System_ERROR_LEVEL
    WARNING_LEVEL = _CsoundAC.System_WARNING_LEVEL
    INFORMATION_LEVEL = _CsoundAC.System_INFORMATION_LEVEL
    DEBUGGING_LEVEL = _CsoundAC.System_DEBUGGING_LEVEL

    def parsePathname(pathname, drive, base, file, extension):
        """parsePathname(std::string const pathname, std::string & drive, std::string & base, std::string & file, std::string & extension)"""
        return _CsoundAC.System_parsePathname(pathname, drive, base, file, extension)

    parsePathname = staticmethod(parsePathname)

    def openLibrary(library, filename):
        """openLibrary(void ** library, std::string filename) -> int"""
        return _CsoundAC.System_openLibrary(library, filename)

    openLibrary = staticmethod(openLibrary)

    def getSymbol(library, name):
        """getSymbol(void * library, std::string name) -> void *"""
        return _CsoundAC.System_getSymbol(library, name)

    getSymbol = staticmethod(getSymbol)

    def closeLibrary(library):
        """closeLibrary(void * library)"""
        return _CsoundAC.System_closeLibrary(library)

    closeLibrary = staticmethod(closeLibrary)

    def getFilenames(directoryName):
        """getFilenames(std::string directoryName) -> std::vector< std::string,std::allocator< std::string > >"""
        return _CsoundAC.System_getFilenames(directoryName)

    getFilenames = staticmethod(getFilenames)

    def getDirectoryNames(directoryName):
        """getDirectoryNames(std::string directoryName) -> std::vector< std::string,std::allocator< std::string > >"""
        return _CsoundAC.System_getDirectoryNames(directoryName)

    getDirectoryNames = staticmethod(getDirectoryNames)

    def createThread(threadRoutine, data, priority):
        """createThread(void (*)(void *) threadRoutine, void * data, int priority) -> void *"""
        return _CsoundAC.System_createThread(threadRoutine, data, priority)

    createThread = staticmethod(createThread)

    def createThreadLock():
        """createThreadLock() -> void *"""
        return _CsoundAC.System_createThreadLock()

    createThreadLock = staticmethod(createThreadLock)

    def waitThreadLock(lock, timeoutMilliseconds=0):
        """
        waitThreadLock(void * lock, size_t timeoutMilliseconds=0)
        waitThreadLock(void * lock)
        """
        return _CsoundAC.System_waitThreadLock(lock, timeoutMilliseconds)

    waitThreadLock = staticmethod(waitThreadLock)

    def notifyThreadLock(lock):
        """notifyThreadLock(void * lock)"""
        return _CsoundAC.System_notifyThreadLock(lock)

    notifyThreadLock = staticmethod(notifyThreadLock)

    def destroyThreadLock(lock):
        """destroyThreadLock(void * lock)"""
        return _CsoundAC.System_destroyThreadLock(lock)

    destroyThreadLock = staticmethod(destroyThreadLock)

    def setMessageLevel(messageLevel):
        """setMessageLevel(int messageLevel) -> int"""
        return _CsoundAC.System_setMessageLevel(messageLevel)

    setMessageLevel = staticmethod(setMessageLevel)

    def yieldThread():
        """yieldThread()"""
        return _CsoundAC.System_yieldThread()

    yieldThread = staticmethod(yieldThread)

    def getMessageLevel():
        """getMessageLevel() -> int"""
        return _CsoundAC.System_getMessageLevel()

    getMessageLevel = staticmethod(getMessageLevel)

    def setUserdata(userdata):
        """setUserdata(void * userdata)"""
        return _CsoundAC.System_setUserdata(userdata)

    setUserdata = staticmethod(setUserdata)

    def getUserdata():
        """getUserdata() -> void *"""
        return _CsoundAC.System_getUserdata()

    getUserdata = staticmethod(getUserdata)

    def setLogfile(logfile):
        """setLogfile(FILE * logfile)"""
        return _CsoundAC.System_setLogfile(logfile)

    setLogfile = staticmethod(setLogfile)

    def getLogfile():
        """getLogfile() -> FILE *"""
        return _CsoundAC.System_getLogfile()

    getLogfile = staticmethod(getLogfile)

    def execute(command):
        """execute(char const * command) -> int"""
        return _CsoundAC.System_execute(command)

    execute = staticmethod(execute)

    def shellOpen(*args):
        """
        shellOpen(char const * filename, char const * command) -> int
        shellOpen(char const * filename) -> int
        """
        return _CsoundAC.System_shellOpen(*args)

    shellOpen = staticmethod(shellOpen)

    def getSharedLibraryExtension():
        """getSharedLibraryExtension() -> std::string"""
        return _CsoundAC.System_getSharedLibraryExtension()

    getSharedLibraryExtension = staticmethod(getSharedLibraryExtension)

    def startTiming():
        """startTiming() -> clock_t"""
        return _CsoundAC.System_startTiming()

    startTiming = staticmethod(startTiming)

    def stopTiming(startedAt):
        """stopTiming(clock_t startedAt) -> double"""
        return _CsoundAC.System_stopTiming(startedAt)

    stopTiming = staticmethod(stopTiming)

    def sleep(milliseconds):
        """sleep(double milliseconds)"""
        return _CsoundAC.System_sleep(milliseconds)

    sleep = staticmethod(sleep)

    def beep():
        """beep()"""
        return _CsoundAC.System_beep()

    beep = staticmethod(beep)

    def __init__(self):
        """__init__(csound::System self) -> System"""
        this = _CsoundAC.new_System()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_System
    __del__ = lambda self: None
System_swigregister = _CsoundAC.System_swigregister
System_swigregister(System)

def System_parsePathname(pathname, drive, base, file, extension):
    """System_parsePathname(std::string const pathname, std::string & drive, std::string & base, std::string & file, std::string & extension)"""
    return _CsoundAC.System_parsePathname(pathname, drive, base, file, extension)

def System_openLibrary(library, filename):
    """System_openLibrary(void ** library, std::string filename) -> int"""
    return _CsoundAC.System_openLibrary(library, filename)

def System_getSymbol(library, name):
    """System_getSymbol(void * library, std::string name) -> void *"""
    return _CsoundAC.System_getSymbol(library, name)

def System_closeLibrary(library):
    """System_closeLibrary(void * library)"""
    return _CsoundAC.System_closeLibrary(library)

def System_getFilenames(directoryName):
    """System_getFilenames(std::string directoryName) -> std::vector< std::string,std::allocator< std::string > >"""
    return _CsoundAC.System_getFilenames(directoryName)

def System_getDirectoryNames(directoryName):
    """System_getDirectoryNames(std::string directoryName) -> std::vector< std::string,std::allocator< std::string > >"""
    return _CsoundAC.System_getDirectoryNames(directoryName)

def System_createThread(threadRoutine, data, priority):
    """System_createThread(void (*)(void *) threadRoutine, void * data, int priority) -> void *"""
    return _CsoundAC.System_createThread(threadRoutine, data, priority)

def System_createThreadLock():
    """System_createThreadLock() -> void *"""
    return _CsoundAC.System_createThreadLock()

def System_waitThreadLock(lock, timeoutMilliseconds=0):
    """
    waitThreadLock(void * lock, size_t timeoutMilliseconds=0)
    System_waitThreadLock(void * lock)
    """
    return _CsoundAC.System_waitThreadLock(lock, timeoutMilliseconds)

def System_notifyThreadLock(lock):
    """System_notifyThreadLock(void * lock)"""
    return _CsoundAC.System_notifyThreadLock(lock)

def System_destroyThreadLock(lock):
    """System_destroyThreadLock(void * lock)"""
    return _CsoundAC.System_destroyThreadLock(lock)

def System_setMessageLevel(messageLevel):
    """System_setMessageLevel(int messageLevel) -> int"""
    return _CsoundAC.System_setMessageLevel(messageLevel)

def System_yieldThread():
    """System_yieldThread()"""
    return _CsoundAC.System_yieldThread()

def System_getMessageLevel():
    """System_getMessageLevel() -> int"""
    return _CsoundAC.System_getMessageLevel()

def System_setUserdata(userdata):
    """System_setUserdata(void * userdata)"""
    return _CsoundAC.System_setUserdata(userdata)

def System_getUserdata():
    """System_getUserdata() -> void *"""
    return _CsoundAC.System_getUserdata()

def System_setLogfile(logfile):
    """System_setLogfile(FILE * logfile)"""
    return _CsoundAC.System_setLogfile(logfile)

def System_getLogfile():
    """System_getLogfile() -> FILE *"""
    return _CsoundAC.System_getLogfile()

def System_execute(command):
    """System_execute(char const * command) -> int"""
    return _CsoundAC.System_execute(command)

def System_shellOpen(*args):
    """
    shellOpen(char const * filename, char const * command) -> int
    System_shellOpen(char const * filename) -> int
    """
    return _CsoundAC.System_shellOpen(*args)

def System_getSharedLibraryExtension():
    """System_getSharedLibraryExtension() -> std::string"""
    return _CsoundAC.System_getSharedLibraryExtension()

def System_startTiming():
    """System_startTiming() -> clock_t"""
    return _CsoundAC.System_startTiming()

def System_stopTiming(startedAt):
    """System_stopTiming(clock_t startedAt) -> double"""
    return _CsoundAC.System_stopTiming(startedAt)

def System_sleep(milliseconds):
    """System_sleep(double milliseconds)"""
    return _CsoundAC.System_sleep(milliseconds)

def System_beep():
    """System_beep()"""
    return _CsoundAC.System_beep()

class ThreadLock(_object):
    """Proxy of C++ csound::ThreadLock class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadLock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadLock, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::ThreadLock self) -> ThreadLock"""
        this = _CsoundAC.new_ThreadLock()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ThreadLock
    __del__ = lambda self: None

    def open(self):
        """open(ThreadLock self)"""
        return _CsoundAC.ThreadLock_open(self)


    def close(self):
        """close(ThreadLock self)"""
        return _CsoundAC.ThreadLock_close(self)


    def isOpen(self):
        """isOpen(ThreadLock self) -> bool"""
        return _CsoundAC.ThreadLock_isOpen(self)


    def startWait(self, timeoutMilliseconds=0):
        """
        startWait(ThreadLock self, size_t timeoutMilliseconds=0)
        startWait(ThreadLock self)
        """
        return _CsoundAC.ThreadLock_startWait(self, timeoutMilliseconds)


    def endWait(self):
        """endWait(ThreadLock self)"""
        return _CsoundAC.ThreadLock_endWait(self)

ThreadLock_swigregister = _CsoundAC.ThreadLock_swigregister
ThreadLock_swigregister(ThreadLock)

class EventVector(_object):
    """Proxy of C++ std::vector<(csound::Event)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EventVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(EventVector self) -> SwigPyIterator"""
        return _CsoundAC.EventVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(EventVector self) -> bool"""
        return _CsoundAC.EventVector___nonzero__(self)


    def __bool__(self):
        """__bool__(EventVector self) -> bool"""
        return _CsoundAC.EventVector___bool__(self)


    def __len__(self):
        """__len__(EventVector self) -> std::vector< csound::Event >::size_type"""
        return _CsoundAC.EventVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(EventVector self, std::vector< csound::Event >::difference_type i, std::vector< csound::Event >::difference_type j) -> EventVector"""
        return _CsoundAC.EventVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(EventVector self, std::vector< csound::Event >::difference_type i, std::vector< csound::Event >::difference_type j)
        __setslice__(EventVector self, std::vector< csound::Event >::difference_type i, std::vector< csound::Event >::difference_type j, EventVector v)
        """
        return _CsoundAC.EventVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(EventVector self, std::vector< csound::Event >::difference_type i, std::vector< csound::Event >::difference_type j)"""
        return _CsoundAC.EventVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(EventVector self, std::vector< csound::Event >::difference_type i)
        __delitem__(EventVector self, PySliceObject * slice)
        """
        return _CsoundAC.EventVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(EventVector self, PySliceObject * slice) -> EventVector
        __getitem__(EventVector self, std::vector< csound::Event >::difference_type i) -> Event
        """
        return _CsoundAC.EventVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(EventVector self, PySliceObject * slice, EventVector v)
        __setitem__(EventVector self, PySliceObject * slice)
        __setitem__(EventVector self, std::vector< csound::Event >::difference_type i, Event x)
        """
        return _CsoundAC.EventVector___setitem__(self, *args)


    def pop(self):
        """pop(EventVector self) -> Event"""
        return _CsoundAC.EventVector_pop(self)


    def append(self, x):
        """append(EventVector self, Event x)"""
        return _CsoundAC.EventVector_append(self, x)


    def empty(self):
        """empty(EventVector self) -> bool"""
        return _CsoundAC.EventVector_empty(self)


    def size(self):
        """size(EventVector self) -> std::vector< csound::Event >::size_type"""
        return _CsoundAC.EventVector_size(self)


    def swap(self, v):
        """swap(EventVector self, EventVector v)"""
        return _CsoundAC.EventVector_swap(self, v)


    def begin(self):
        """begin(EventVector self) -> std::vector< csound::Event >::iterator"""
        return _CsoundAC.EventVector_begin(self)


    def end(self):
        """end(EventVector self) -> std::vector< csound::Event >::iterator"""
        return _CsoundAC.EventVector_end(self)


    def rbegin(self):
        """rbegin(EventVector self) -> std::vector< csound::Event >::reverse_iterator"""
        return _CsoundAC.EventVector_rbegin(self)


    def rend(self):
        """rend(EventVector self) -> std::vector< csound::Event >::reverse_iterator"""
        return _CsoundAC.EventVector_rend(self)


    def clear(self):
        """clear(EventVector self)"""
        return _CsoundAC.EventVector_clear(self)


    def get_allocator(self):
        """get_allocator(EventVector self) -> std::vector< csound::Event >::allocator_type"""
        return _CsoundAC.EventVector_get_allocator(self)


    def pop_back(self):
        """pop_back(EventVector self)"""
        return _CsoundAC.EventVector_pop_back(self)


    def erase(self, *args):
        """
        erase(EventVector self, std::vector< csound::Event >::iterator pos) -> std::vector< csound::Event >::iterator
        erase(EventVector self, std::vector< csound::Event >::iterator first, std::vector< csound::Event >::iterator last) -> std::vector< csound::Event >::iterator
        """
        return _CsoundAC.EventVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(csound::Event)> self) -> EventVector
        __init__(std::vector<(csound::Event)> self, EventVector arg2) -> EventVector
        __init__(std::vector<(csound::Event)> self, std::vector< csound::Event >::size_type size) -> EventVector
        __init__(std::vector<(csound::Event)> self, std::vector< csound::Event >::size_type size, Event value) -> EventVector
        """
        this = _CsoundAC.new_EventVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(EventVector self, Event x)"""
        return _CsoundAC.EventVector_push_back(self, x)


    def front(self):
        """front(EventVector self) -> Event"""
        return _CsoundAC.EventVector_front(self)


    def back(self):
        """back(EventVector self) -> Event"""
        return _CsoundAC.EventVector_back(self)


    def assign(self, n, x):
        """assign(EventVector self, std::vector< csound::Event >::size_type n, Event x)"""
        return _CsoundAC.EventVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(EventVector self, std::vector< csound::Event >::size_type new_size)
        resize(EventVector self, std::vector< csound::Event >::size_type new_size, Event x)
        """
        return _CsoundAC.EventVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(EventVector self, std::vector< csound::Event >::iterator pos, Event x) -> std::vector< csound::Event >::iterator
        insert(EventVector self, std::vector< csound::Event >::iterator pos, std::vector< csound::Event >::size_type n, Event x)
        """
        return _CsoundAC.EventVector_insert(self, *args)


    def reserve(self, n):
        """reserve(EventVector self, std::vector< csound::Event >::size_type n)"""
        return _CsoundAC.EventVector_reserve(self, n)


    def capacity(self):
        """capacity(EventVector self) -> std::vector< csound::Event >::size_type"""
        return _CsoundAC.EventVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_EventVector
    __del__ = lambda self: None
EventVector_swigregister = _CsoundAC.EventVector_swigregister
EventVector_swigregister(EventVector)

class Event(_object):
    """Proxy of C++ csound::Event class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
    __repr__ = _swig_repr
    TIME = _CsoundAC.Event_TIME
    DURATION = _CsoundAC.Event_DURATION
    STATUS = _CsoundAC.Event_STATUS
    INSTRUMENT = _CsoundAC.Event_INSTRUMENT
    KEY = _CsoundAC.Event_KEY
    VELOCITY = _CsoundAC.Event_VELOCITY
    PHASE = _CsoundAC.Event_PHASE
    PAN = _CsoundAC.Event_PAN
    DEPTH = _CsoundAC.Event_DEPTH
    HEIGHT = _CsoundAC.Event_HEIGHT
    PITCHES = _CsoundAC.Event_PITCHES
    HOMOGENEITY = _CsoundAC.Event_HOMOGENEITY
    ELEMENT_COUNT = _CsoundAC.Event_ELEMENT_COUNT
    INDEFINITE = _CsoundAC.Event_INDEFINITE
    __swig_setmethods__["properties"] = _CsoundAC.Event_properties_set
    __swig_getmethods__["properties"] = _CsoundAC.Event_properties_get
    if _newclass:
        properties = _swig_property(_CsoundAC.Event_properties_get, _CsoundAC.Event_properties_set)

    def __init__(self, *args):
        """
        __init__(csound::Event self) -> Event
        __init__(csound::Event self, Event a) -> Event
        __init__(csound::Event self, std::string text) -> Event
        __init__(csound::Event self, Eigen::VectorXd const & a) -> Event
        __init__(csound::Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase, double pan, double depth, double height, double pitches) -> Event
        __init__(csound::Event self, DoubleVector v) -> Event
        """
        this = _CsoundAC.new_Event(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Event
    __del__ = lambda self: None

    def initialize(self):
        """initialize(Event self)"""
        return _CsoundAC.Event_initialize(self)


    def isMidiEvent(self):
        """isMidiEvent(Event self) -> bool"""
        return _CsoundAC.Event_isMidiEvent(self)


    def isNoteOn(self):
        """isNoteOn(Event self) -> bool"""
        return _CsoundAC.Event_isNoteOn(self)


    def isNoteOff(self):
        """isNoteOff(Event self) -> bool"""
        return _CsoundAC.Event_isNoteOff(self)


    def isNote(self):
        """isNote(Event self) -> bool"""
        return _CsoundAC.Event_isNote(self)


    def isMatchingNoteOff(self, event):
        """isMatchingNoteOff(Event self, Event event) -> bool"""
        return _CsoundAC.Event_isMatchingNoteOff(self, event)


    def isMatchingEvent(self, event):
        """isMatchingEvent(Event self, Event event) -> bool"""
        return _CsoundAC.Event_isMatchingEvent(self, event)


    def set(self, time, duration, status, instrument, key, velocity, phase=0, pan=0, depth=0, height=0, pitches=4095):
        """
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase=0, double pan=0, double depth=0, double height=0, double pitches=4095)
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase=0, double pan=0, double depth=0, double height=0)
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase=0, double pan=0, double depth=0)
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase=0, double pan=0)
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity, double phase=0)
        set(Event self, double time, double duration, double status, double instrument, double key, double velocity)
        """
        return _CsoundAC.Event_set(self, time, duration, status, instrument, key, velocity, phase, pan, depth, height, pitches)


    def setMidi(self, time, status, key, velocity):
        """setMidi(Event self, double time, char status, char key, char velocity)"""
        return _CsoundAC.Event_setMidi(self, time, status, key, velocity)


    def getMidiStatus(self):
        """getMidiStatus(Event self) -> int"""
        return _CsoundAC.Event_getMidiStatus(self)


    def getStatusNumber(self):
        """getStatusNumber(Event self) -> int"""
        return _CsoundAC.Event_getStatusNumber(self)


    def getStatus(self):
        """getStatus(Event self) -> double"""
        return _CsoundAC.Event_getStatus(self)


    def setStatus(self, status):
        """setStatus(Event self, double status)"""
        return _CsoundAC.Event_setStatus(self, status)


    def getChannel(self):
        """getChannel(Event self) -> int"""
        return _CsoundAC.Event_getChannel(self)


    def getInstrument(self):
        """getInstrument(Event self) -> double"""
        return _CsoundAC.Event_getInstrument(self)


    def setInstrument(self, instrument):
        """setInstrument(Event self, double instrument)"""
        return _CsoundAC.Event_setInstrument(self, instrument)


    def getTime(self):
        """getTime(Event self) -> double"""
        return _CsoundAC.Event_getTime(self)


    def setTime(self, time):
        """setTime(Event self, double time)"""
        return _CsoundAC.Event_setTime(self, time)


    def getDuration(self):
        """getDuration(Event self) -> double"""
        return _CsoundAC.Event_getDuration(self)


    def setDuration(self, duration):
        """setDuration(Event self, double duration)"""
        return _CsoundAC.Event_setDuration(self, duration)


    def getOffTime(self):
        """getOffTime(Event self) -> double"""
        return _CsoundAC.Event_getOffTime(self)


    def setOffTime(self, offTime):
        """setOffTime(Event self, double offTime)"""
        return _CsoundAC.Event_setOffTime(self, offTime)


    def getKeyNumber(self):
        """getKeyNumber(Event self) -> int"""
        return _CsoundAC.Event_getKeyNumber(self)


    def getKey(self, *args):
        """
        getKey(Event self) -> double
        getKey(Event self, double tonesPerOctave) -> double
        """
        return _CsoundAC.Event_getKey(self, *args)


    def setKey(self, key):
        """setKey(Event self, double key)"""
        return _CsoundAC.Event_setKey(self, key)


    def getFrequency(self):
        """getFrequency(Event self) -> double"""
        return _CsoundAC.Event_getFrequency(self)


    def setFrequency(self, frequency):
        """setFrequency(Event self, double frequency)"""
        return _CsoundAC.Event_setFrequency(self, frequency)


    def getVelocityNumber(self):
        """getVelocityNumber(Event self) -> int"""
        return _CsoundAC.Event_getVelocityNumber(self)


    def getVelocity(self):
        """getVelocity(Event self) -> double"""
        return _CsoundAC.Event_getVelocity(self)


    def setVelocity(self, velocity):
        """setVelocity(Event self, double velocity)"""
        return _CsoundAC.Event_setVelocity(self, velocity)


    def getGain(self):
        """getGain(Event self) -> double"""
        return _CsoundAC.Event_getGain(self)


    def getPan(self):
        """getPan(Event self) -> double"""
        return _CsoundAC.Event_getPan(self)


    def setPan(self, pan):
        """setPan(Event self, double pan)"""
        return _CsoundAC.Event_setPan(self, pan)


    def getDepth(self):
        """getDepth(Event self) -> double"""
        return _CsoundAC.Event_getDepth(self)


    def setDepth(self, depth):
        """setDepth(Event self, double depth)"""
        return _CsoundAC.Event_setDepth(self, depth)


    def getHeight(self):
        """getHeight(Event self) -> double"""
        return _CsoundAC.Event_getHeight(self)


    def setHeight(self, height):
        """setHeight(Event self, double height)"""
        return _CsoundAC.Event_setHeight(self, height)


    def getPitches(self):
        """getPitches(Event self) -> double"""
        return _CsoundAC.Event_getPitches(self)


    def setPitches(self, pitches):
        """setPitches(Event self, double pitches)"""
        return _CsoundAC.Event_setPitches(self, pitches)


    def getAmplitude(self):
        """getAmplitude(Event self) -> double"""
        return _CsoundAC.Event_getAmplitude(self)


    def setAmplitude(self, amplitude):
        """setAmplitude(Event self, double amplitude)"""
        return _CsoundAC.Event_setAmplitude(self, amplitude)


    def getPhase(self):
        """getPhase(Event self) -> double"""
        return _CsoundAC.Event_getPhase(self)


    def setPhase(self, phase):
        """setPhase(Event self, double phase)"""
        return _CsoundAC.Event_setPhase(self, phase)


    def getLeftGain(self):
        """getLeftGain(Event self) -> double"""
        return _CsoundAC.Event_getLeftGain(self)


    def getRightGain(self):
        """getRightGain(Event self) -> double"""
        return _CsoundAC.Event_getRightGain(self)


    def dump(self, stream):
        """dump(Event self, std::ostream & stream)"""
        return _CsoundAC.Event_dump(self, stream)


    def toString(self):
        """toString(Event self) -> std::string"""
        return _CsoundAC.Event_toString(self)


    def toCsoundIStatement(self, tempering=12.0):
        """
        toCsoundIStatement(Event self, double tempering=12.0) -> std::string
        toCsoundIStatement(Event self) -> std::string
        """
        return _CsoundAC.Event_toCsoundIStatement(self, tempering)


    def toCsoundIStatementHeld(self, tag, tempering=12.0):
        """
        toCsoundIStatementHeld(Event self, int tag, double tempering=12.0) -> std::string
        toCsoundIStatementHeld(Event self, int tag) -> std::string
        """
        return _CsoundAC.Event_toCsoundIStatementHeld(self, tag, tempering)


    def toCsoundIStatementRelease(self, tag, tempering=12.0):
        """
        toCsoundIStatementRelease(Event self, int tag, double tempering=12.0) -> std::string
        toCsoundIStatementRelease(Event self, int tag) -> std::string
        """
        return _CsoundAC.Event_toCsoundIStatementRelease(self, tag, tempering)


    def conformToPitchClassSet(self):
        """conformToPitchClassSet(Event self)"""
        return _CsoundAC.Event_conformToPitchClassSet(self)


    def temper(self, divisionsPerOctave):
        """temper(Event self, double divisionsPerOctave)"""
        return _CsoundAC.Event_temper(self, divisionsPerOctave)


    def getProperty(self, name):
        """getProperty(Event self, std::string name) -> std::string"""
        return _CsoundAC.Event_getProperty(self, name)


    def setProperty(self, name, value):
        """setProperty(Event self, std::string name, std::string value)"""
        return _CsoundAC.Event_setProperty(self, name, value)


    def removeProperty(self, nameO):
        """removeProperty(Event self, std::string nameO)"""
        return _CsoundAC.Event_removeProperty(self, nameO)


    def clearProperties(self):
        """clearProperties(Event self)"""
        return _CsoundAC.Event_clearProperties(self)


    def createNoteOffEvent(self, event):
        """createNoteOffEvent(Event self, Event event)"""
        return _CsoundAC.Event_createNoteOffEvent(self, event)

Event_swigregister = _CsoundAC.Event_swigregister
Event_swigregister(Event)

class MidiEventVector(_object):
    """Proxy of C++ std::vector<(csound::MidiEvent)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiEventVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MidiEventVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(MidiEventVector self) -> SwigPyIterator"""
        return _CsoundAC.MidiEventVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(MidiEventVector self) -> bool"""
        return _CsoundAC.MidiEventVector___nonzero__(self)


    def __bool__(self):
        """__bool__(MidiEventVector self) -> bool"""
        return _CsoundAC.MidiEventVector___bool__(self)


    def __len__(self):
        """__len__(MidiEventVector self) -> std::vector< csound::MidiEvent >::size_type"""
        return _CsoundAC.MidiEventVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i, std::vector< csound::MidiEvent >::difference_type j) -> MidiEventVector"""
        return _CsoundAC.MidiEventVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i, std::vector< csound::MidiEvent >::difference_type j)
        __setslice__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i, std::vector< csound::MidiEvent >::difference_type j, MidiEventVector v)
        """
        return _CsoundAC.MidiEventVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i, std::vector< csound::MidiEvent >::difference_type j)"""
        return _CsoundAC.MidiEventVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i)
        __delitem__(MidiEventVector self, PySliceObject * slice)
        """
        return _CsoundAC.MidiEventVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MidiEventVector self, PySliceObject * slice) -> MidiEventVector
        __getitem__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i) -> MidiEvent
        """
        return _CsoundAC.MidiEventVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MidiEventVector self, PySliceObject * slice, MidiEventVector v)
        __setitem__(MidiEventVector self, PySliceObject * slice)
        __setitem__(MidiEventVector self, std::vector< csound::MidiEvent >::difference_type i, MidiEvent x)
        """
        return _CsoundAC.MidiEventVector___setitem__(self, *args)


    def pop(self):
        """pop(MidiEventVector self) -> MidiEvent"""
        return _CsoundAC.MidiEventVector_pop(self)


    def append(self, x):
        """append(MidiEventVector self, MidiEvent x)"""
        return _CsoundAC.MidiEventVector_append(self, x)


    def empty(self):
        """empty(MidiEventVector self) -> bool"""
        return _CsoundAC.MidiEventVector_empty(self)


    def size(self):
        """size(MidiEventVector self) -> std::vector< csound::MidiEvent >::size_type"""
        return _CsoundAC.MidiEventVector_size(self)


    def swap(self, v):
        """swap(MidiEventVector self, MidiEventVector v)"""
        return _CsoundAC.MidiEventVector_swap(self, v)


    def begin(self):
        """begin(MidiEventVector self) -> std::vector< csound::MidiEvent >::iterator"""
        return _CsoundAC.MidiEventVector_begin(self)


    def end(self):
        """end(MidiEventVector self) -> std::vector< csound::MidiEvent >::iterator"""
        return _CsoundAC.MidiEventVector_end(self)


    def rbegin(self):
        """rbegin(MidiEventVector self) -> std::vector< csound::MidiEvent >::reverse_iterator"""
        return _CsoundAC.MidiEventVector_rbegin(self)


    def rend(self):
        """rend(MidiEventVector self) -> std::vector< csound::MidiEvent >::reverse_iterator"""
        return _CsoundAC.MidiEventVector_rend(self)


    def clear(self):
        """clear(MidiEventVector self)"""
        return _CsoundAC.MidiEventVector_clear(self)


    def get_allocator(self):
        """get_allocator(MidiEventVector self) -> std::vector< csound::MidiEvent >::allocator_type"""
        return _CsoundAC.MidiEventVector_get_allocator(self)


    def pop_back(self):
        """pop_back(MidiEventVector self)"""
        return _CsoundAC.MidiEventVector_pop_back(self)


    def erase(self, *args):
        """
        erase(MidiEventVector self, std::vector< csound::MidiEvent >::iterator pos) -> std::vector< csound::MidiEvent >::iterator
        erase(MidiEventVector self, std::vector< csound::MidiEvent >::iterator first, std::vector< csound::MidiEvent >::iterator last) -> std::vector< csound::MidiEvent >::iterator
        """
        return _CsoundAC.MidiEventVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(csound::MidiEvent)> self) -> MidiEventVector
        __init__(std::vector<(csound::MidiEvent)> self, MidiEventVector arg2) -> MidiEventVector
        __init__(std::vector<(csound::MidiEvent)> self, std::vector< csound::MidiEvent >::size_type size) -> MidiEventVector
        __init__(std::vector<(csound::MidiEvent)> self, std::vector< csound::MidiEvent >::size_type size, MidiEvent value) -> MidiEventVector
        """
        this = _CsoundAC.new_MidiEventVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MidiEventVector self, MidiEvent x)"""
        return _CsoundAC.MidiEventVector_push_back(self, x)


    def front(self):
        """front(MidiEventVector self) -> MidiEvent"""
        return _CsoundAC.MidiEventVector_front(self)


    def back(self):
        """back(MidiEventVector self) -> MidiEvent"""
        return _CsoundAC.MidiEventVector_back(self)


    def assign(self, n, x):
        """assign(MidiEventVector self, std::vector< csound::MidiEvent >::size_type n, MidiEvent x)"""
        return _CsoundAC.MidiEventVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MidiEventVector self, std::vector< csound::MidiEvent >::size_type new_size)
        resize(MidiEventVector self, std::vector< csound::MidiEvent >::size_type new_size, MidiEvent x)
        """
        return _CsoundAC.MidiEventVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(MidiEventVector self, std::vector< csound::MidiEvent >::iterator pos, MidiEvent x) -> std::vector< csound::MidiEvent >::iterator
        insert(MidiEventVector self, std::vector< csound::MidiEvent >::iterator pos, std::vector< csound::MidiEvent >::size_type n, MidiEvent x)
        """
        return _CsoundAC.MidiEventVector_insert(self, *args)


    def reserve(self, n):
        """reserve(MidiEventVector self, std::vector< csound::MidiEvent >::size_type n)"""
        return _CsoundAC.MidiEventVector_reserve(self, n)


    def capacity(self):
        """capacity(MidiEventVector self) -> std::vector< csound::MidiEvent >::size_type"""
        return _CsoundAC.MidiEventVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_MidiEventVector
    __del__ = lambda self: None
MidiEventVector_swigregister = _CsoundAC.MidiEventVector_swigregister
MidiEventVector_swigregister(MidiEventVector)

class MidiByteVector(_object):
    """Proxy of C++ std::vector<(unsigned char)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiByteVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MidiByteVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(MidiByteVector self) -> SwigPyIterator"""
        return _CsoundAC.MidiByteVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(MidiByteVector self) -> bool"""
        return _CsoundAC.MidiByteVector___nonzero__(self)


    def __bool__(self):
        """__bool__(MidiByteVector self) -> bool"""
        return _CsoundAC.MidiByteVector___bool__(self)


    def __len__(self):
        """__len__(MidiByteVector self) -> std::vector< unsigned char >::size_type"""
        return _CsoundAC.MidiByteVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MidiByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> MidiByteVector"""
        return _CsoundAC.MidiByteVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MidiByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        __setslice__(MidiByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, MidiByteVector v)
        """
        return _CsoundAC.MidiByteVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MidiByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _CsoundAC.MidiByteVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MidiByteVector self, std::vector< unsigned char >::difference_type i)
        __delitem__(MidiByteVector self, PySliceObject * slice)
        """
        return _CsoundAC.MidiByteVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MidiByteVector self, PySliceObject * slice) -> MidiByteVector
        __getitem__(MidiByteVector self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _CsoundAC.MidiByteVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MidiByteVector self, PySliceObject * slice, MidiByteVector v)
        __setitem__(MidiByteVector self, PySliceObject * slice)
        __setitem__(MidiByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _CsoundAC.MidiByteVector___setitem__(self, *args)


    def pop(self):
        """pop(MidiByteVector self) -> std::vector< unsigned char >::value_type"""
        return _CsoundAC.MidiByteVector_pop(self)


    def append(self, x):
        """append(MidiByteVector self, std::vector< unsigned char >::value_type const & x)"""
        return _CsoundAC.MidiByteVector_append(self, x)


    def empty(self):
        """empty(MidiByteVector self) -> bool"""
        return _CsoundAC.MidiByteVector_empty(self)


    def size(self):
        """size(MidiByteVector self) -> std::vector< unsigned char >::size_type"""
        return _CsoundAC.MidiByteVector_size(self)


    def swap(self, v):
        """swap(MidiByteVector self, MidiByteVector v)"""
        return _CsoundAC.MidiByteVector_swap(self, v)


    def begin(self):
        """begin(MidiByteVector self) -> std::vector< unsigned char >::iterator"""
        return _CsoundAC.MidiByteVector_begin(self)


    def end(self):
        """end(MidiByteVector self) -> std::vector< unsigned char >::iterator"""
        return _CsoundAC.MidiByteVector_end(self)


    def rbegin(self):
        """rbegin(MidiByteVector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _CsoundAC.MidiByteVector_rbegin(self)


    def rend(self):
        """rend(MidiByteVector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _CsoundAC.MidiByteVector_rend(self)


    def clear(self):
        """clear(MidiByteVector self)"""
        return _CsoundAC.MidiByteVector_clear(self)


    def get_allocator(self):
        """get_allocator(MidiByteVector self) -> std::vector< unsigned char >::allocator_type"""
        return _CsoundAC.MidiByteVector_get_allocator(self)


    def pop_back(self):
        """pop_back(MidiByteVector self)"""
        return _CsoundAC.MidiByteVector_pop_back(self)


    def erase(self, *args):
        """
        erase(MidiByteVector self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(MidiByteVector self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _CsoundAC.MidiByteVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(unsigned char)> self) -> MidiByteVector
        __init__(std::vector<(unsigned char)> self, MidiByteVector arg2) -> MidiByteVector
        __init__(std::vector<(unsigned char)> self, std::vector< unsigned char >::size_type size) -> MidiByteVector
        __init__(std::vector<(unsigned char)> self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> MidiByteVector
        """
        this = _CsoundAC.new_MidiByteVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MidiByteVector self, std::vector< unsigned char >::value_type const & x)"""
        return _CsoundAC.MidiByteVector_push_back(self, x)


    def front(self):
        """front(MidiByteVector self) -> std::vector< unsigned char >::value_type const &"""
        return _CsoundAC.MidiByteVector_front(self)


    def back(self):
        """back(MidiByteVector self) -> std::vector< unsigned char >::value_type const &"""
        return _CsoundAC.MidiByteVector_back(self)


    def assign(self, n, x):
        """assign(MidiByteVector self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _CsoundAC.MidiByteVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MidiByteVector self, std::vector< unsigned char >::size_type new_size)
        resize(MidiByteVector self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _CsoundAC.MidiByteVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(MidiByteVector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(MidiByteVector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)
        """
        return _CsoundAC.MidiByteVector_insert(self, *args)


    def reserve(self, n):
        """reserve(MidiByteVector self, std::vector< unsigned char >::size_type n)"""
        return _CsoundAC.MidiByteVector_reserve(self, n)


    def capacity(self):
        """capacity(MidiByteVector self) -> std::vector< unsigned char >::size_type"""
        return _CsoundAC.MidiByteVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_MidiByteVector
    __del__ = lambda self: None
MidiByteVector_swigregister = _CsoundAC.MidiByteVector_swigregister
MidiByteVector_swigregister(MidiByteVector)

class Chunk(_object):
    """Proxy of C++ csound::Chunk class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chunk, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chunk, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id"] = _CsoundAC.Chunk_id_set
    __swig_getmethods__["id"] = _CsoundAC.Chunk_id_get
    if _newclass:
        id = _swig_property(_CsoundAC.Chunk_id_get, _CsoundAC.Chunk_id_set)
    __swig_setmethods__["chunkSize"] = _CsoundAC.Chunk_chunkSize_set
    __swig_getmethods__["chunkSize"] = _CsoundAC.Chunk_chunkSize_get
    if _newclass:
        chunkSize = _swig_property(_CsoundAC.Chunk_chunkSize_get, _CsoundAC.Chunk_chunkSize_set)
    __swig_setmethods__["chunkSizePosition"] = _CsoundAC.Chunk_chunkSizePosition_set
    __swig_getmethods__["chunkSizePosition"] = _CsoundAC.Chunk_chunkSizePosition_get
    if _newclass:
        chunkSizePosition = _swig_property(_CsoundAC.Chunk_chunkSizePosition_get, _CsoundAC.Chunk_chunkSizePosition_set)
    __swig_setmethods__["chunkStart"] = _CsoundAC.Chunk_chunkStart_set
    __swig_getmethods__["chunkStart"] = _CsoundAC.Chunk_chunkStart_get
    if _newclass:
        chunkStart = _swig_property(_CsoundAC.Chunk_chunkStart_get, _CsoundAC.Chunk_chunkStart_set)
    __swig_setmethods__["chunkEnd"] = _CsoundAC.Chunk_chunkEnd_set
    __swig_getmethods__["chunkEnd"] = _CsoundAC.Chunk_chunkEnd_get
    if _newclass:
        chunkEnd = _swig_property(_CsoundAC.Chunk_chunkEnd_get, _CsoundAC.Chunk_chunkEnd_set)

    def __init__(self, *args):
        """
        __init__(csound::Chunk self) -> Chunk
        __init__(csound::Chunk self, char const * _id) -> Chunk
        __init__(csound::Chunk self, Chunk a) -> Chunk
        """
        this = _CsoundAC.new_Chunk(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Chunk
    __del__ = lambda self: None

    def read(self, stream):
        """read(Chunk self, std::istream & stream)"""
        return _CsoundAC.Chunk_read(self, stream)


    def write(self, stream):
        """write(Chunk self, std::ostream & stream)"""
        return _CsoundAC.Chunk_write(self, stream)


    def markChunkSize(self, stream):
        """markChunkSize(Chunk self, std::ostream & stream)"""
        return _CsoundAC.Chunk_markChunkSize(self, stream)


    def markChunkStart(self, stream):
        """markChunkStart(Chunk self, std::ostream & stream)"""
        return _CsoundAC.Chunk_markChunkStart(self, stream)


    def markChunkEnd(self, stream):
        """markChunkEnd(Chunk self, std::ostream & stream)"""
        return _CsoundAC.Chunk_markChunkEnd(self, stream)

Chunk_swigregister = _CsoundAC.Chunk_swigregister
Chunk_swigregister(Chunk)

class MidiHeader(Chunk):
    """Proxy of C++ csound::MidiHeader class."""

    __swig_setmethods__ = {}
    for _s in [Chunk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiHeader, name, value)
    __swig_getmethods__ = {}
    for _s in [Chunk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MidiHeader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _CsoundAC.MidiHeader_type_set
    __swig_getmethods__["type"] = _CsoundAC.MidiHeader_type_get
    if _newclass:
        type = _swig_property(_CsoundAC.MidiHeader_type_get, _CsoundAC.MidiHeader_type_set)
    __swig_setmethods__["trackCount"] = _CsoundAC.MidiHeader_trackCount_set
    __swig_getmethods__["trackCount"] = _CsoundAC.MidiHeader_trackCount_get
    if _newclass:
        trackCount = _swig_property(_CsoundAC.MidiHeader_trackCount_get, _CsoundAC.MidiHeader_trackCount_set)
    __swig_setmethods__["timeFormat"] = _CsoundAC.MidiHeader_timeFormat_set
    __swig_getmethods__["timeFormat"] = _CsoundAC.MidiHeader_timeFormat_get
    if _newclass:
        timeFormat = _swig_property(_CsoundAC.MidiHeader_timeFormat_get, _CsoundAC.MidiHeader_timeFormat_set)

    def __init__(self, *args):
        """
        __init__(csound::MidiHeader self) -> MidiHeader
        __init__(csound::MidiHeader self, MidiHeader a) -> MidiHeader
        """
        this = _CsoundAC.new_MidiHeader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MidiHeader
    __del__ = lambda self: None

    def clear(self):
        """clear(MidiHeader self)"""
        return _CsoundAC.MidiHeader_clear(self)


    def read(self, stream):
        """read(MidiHeader self, std::istream & stream)"""
        return _CsoundAC.MidiHeader_read(self, stream)


    def write(self, stream):
        """write(MidiHeader self, std::ostream & stream)"""
        return _CsoundAC.MidiHeader_write(self, stream)

MidiHeader_swigregister = _CsoundAC.MidiHeader_swigregister
MidiHeader_swigregister(MidiHeader)

class MidiEvent(MidiByteVector):
    """Proxy of C++ csound::MidiEvent class."""

    __swig_setmethods__ = {}
    for _s in [MidiByteVector]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiEvent, name, value)
    __swig_getmethods__ = {}
    for _s in [MidiByteVector]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MidiEvent, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ticks"] = _CsoundAC.MidiEvent_ticks_set
    __swig_getmethods__["ticks"] = _CsoundAC.MidiEvent_ticks_get
    if _newclass:
        ticks = _swig_property(_CsoundAC.MidiEvent_ticks_get, _CsoundAC.MidiEvent_ticks_set)
    __swig_setmethods__["time"] = _CsoundAC.MidiEvent_time_set
    __swig_getmethods__["time"] = _CsoundAC.MidiEvent_time_get
    if _newclass:
        time = _swig_property(_CsoundAC.MidiEvent_time_get, _CsoundAC.MidiEvent_time_set)

    def __init__(self, *args):
        """
        __init__(csound::MidiEvent self) -> MidiEvent
        __init__(csound::MidiEvent self, MidiEvent a) -> MidiEvent
        """
        this = _CsoundAC.new_MidiEvent(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MidiEvent
    __del__ = lambda self: None

    def write(self, stream, midiFile, lastTick):
        """write(MidiEvent self, std::ostream & stream, MidiFile midiFile, int lastTick)"""
        return _CsoundAC.MidiEvent_write(self, stream, midiFile, lastTick)


    def getStatus(self):
        """getStatus(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getStatus(self)


    def getStatusNybble(self):
        """getStatusNybble(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getStatusNybble(self)


    def getChannelNybble(self):
        """getChannelNybble(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getChannelNybble(self)


    def getKey(self):
        """getKey(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getKey(self)


    def getVelocity(self):
        """getVelocity(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getVelocity(self)


    def getMetaType(self):
        """getMetaType(MidiEvent self) -> int"""
        return _CsoundAC.MidiEvent_getMetaType(self)


    def getMetaData(self, i):
        """getMetaData(MidiEvent self, int i) -> unsigned char"""
        return _CsoundAC.MidiEvent_getMetaData(self, i)


    def getMetaSize(self):
        """getMetaSize(MidiEvent self) -> size_t"""
        return _CsoundAC.MidiEvent_getMetaSize(self)


    def read(self, *args):
        """
        read(MidiEvent self, std::istream & stream, MidiFile midiFile)
        read(MidiEvent self, std::istream & stream) -> unsigned char
        """
        return _CsoundAC.MidiEvent_read(self, *args)


    def isChannelVoiceMessage(self):
        """isChannelVoiceMessage(MidiEvent self) -> bool"""
        return _CsoundAC.MidiEvent_isChannelVoiceMessage(self)


    def isNoteOn(self):
        """isNoteOn(MidiEvent self) -> bool"""
        return _CsoundAC.MidiEvent_isNoteOn(self)


    def isNoteOff(self):
        """isNoteOff(MidiEvent self) -> bool"""
        return _CsoundAC.MidiEvent_isNoteOff(self)


    def matchesNoteOffEvent(self, offEvent):
        """matchesNoteOffEvent(MidiEvent self, MidiEvent offEvent) -> bool"""
        return _CsoundAC.MidiEvent_matchesNoteOffEvent(self, offEvent)


    def toString(self):
        """toString(MidiEvent self) -> std::string"""
        return _CsoundAC.MidiEvent_toString(self)

MidiEvent_swigregister = _CsoundAC.MidiEvent_swigregister
MidiEvent_swigregister(MidiEvent)

class MidiTrack(Chunk, MidiEventVector):
    """Proxy of C++ csound::MidiTrack class."""

    __swig_setmethods__ = {}
    for _s in [Chunk, MidiEventVector]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiTrack, name, value)
    __swig_getmethods__ = {}
    for _s in [Chunk, MidiEventVector]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MidiTrack, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::MidiTrack self) -> MidiTrack"""
        this = _CsoundAC.new_MidiTrack()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MidiTrack
    __del__ = lambda self: None

    def read(self, stream, midiFile):
        """read(MidiTrack self, std::istream & stream, MidiFile midiFile)"""
        return _CsoundAC.MidiTrack_read(self, stream, midiFile)


    def write(self, stream, midiFile):
        """write(MidiTrack self, std::ostream & stream, MidiFile midiFile)"""
        return _CsoundAC.MidiTrack_write(self, stream, midiFile)

MidiTrack_swigregister = _CsoundAC.MidiTrack_swigregister
MidiTrack_swigregister(MidiTrack)

class TempoMap(_object):
    """Proxy of C++ csound::TempoMap class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TempoMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TempoMap, name)
    __repr__ = _swig_repr

    def getCurrentSecondsPerTick(self, tick):
        """getCurrentSecondsPerTick(TempoMap self, int tick) -> double"""
        return _CsoundAC.TempoMap_getCurrentSecondsPerTick(self, tick)


    def __init__(self):
        """__init__(csound::TempoMap self) -> TempoMap"""
        this = _CsoundAC.new_TempoMap()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_TempoMap
    __del__ = lambda self: None
TempoMap_swigregister = _CsoundAC.TempoMap_swigregister
TempoMap_swigregister(TempoMap)

class MidiFile(_object):
    """Proxy of C++ csound::MidiFile class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiFile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MidiFile, name)
    __repr__ = _swig_repr
    CHANNEL_NOTE_OFF = _CsoundAC.MidiFile_CHANNEL_NOTE_OFF
    CHANNEL_NOTE_ON = _CsoundAC.MidiFile_CHANNEL_NOTE_ON
    CHANNEL_KEY_PRESSURE = _CsoundAC.MidiFile_CHANNEL_KEY_PRESSURE
    CHANNEL_CONTROL_CHANGE = _CsoundAC.MidiFile_CHANNEL_CONTROL_CHANGE
    CHANNEL_PROGRAM_CHANGE = _CsoundAC.MidiFile_CHANNEL_PROGRAM_CHANGE
    CHANNEL_AFTER_TOUCH = _CsoundAC.MidiFile_CHANNEL_AFTER_TOUCH
    CHANNEL_PITCH_BEND = _CsoundAC.MidiFile_CHANNEL_PITCH_BEND
    SYSTEM_EXCLUSIVE = _CsoundAC.MidiFile_SYSTEM_EXCLUSIVE
    SYSTEM_MIDI_TIME_CODE = _CsoundAC.MidiFile_SYSTEM_MIDI_TIME_CODE
    SYSTEM_SONG_POSITION_POINTER = _CsoundAC.MidiFile_SYSTEM_SONG_POSITION_POINTER
    SYSTEM_SONG_SELECT = _CsoundAC.MidiFile_SYSTEM_SONG_SELECT
    SYSTEM_TUNE_REQUEST = _CsoundAC.MidiFile_SYSTEM_TUNE_REQUEST
    SYSTEM_END_OF_EXCLUSIVE = _CsoundAC.MidiFile_SYSTEM_END_OF_EXCLUSIVE
    SYSTEM_TIMING_CLOCK = _CsoundAC.MidiFile_SYSTEM_TIMING_CLOCK
    SYSTEM_START = _CsoundAC.MidiFile_SYSTEM_START
    SYSTEM_CONTINUE = _CsoundAC.MidiFile_SYSTEM_CONTINUE
    SYSTEM_STOP = _CsoundAC.MidiFile_SYSTEM_STOP
    SYSTEM_ACTIVE_SENSING = _CsoundAC.MidiFile_SYSTEM_ACTIVE_SENSING
    META_EVENT = _CsoundAC.MidiFile_META_EVENT
    META_SEQUENCE_NUMBER = _CsoundAC.MidiFile_META_SEQUENCE_NUMBER
    META_TEXT_EVENT = _CsoundAC.MidiFile_META_TEXT_EVENT
    META_COPYRIGHT_NOTICE = _CsoundAC.MidiFile_META_COPYRIGHT_NOTICE
    META_SEQUENCE_NAME = _CsoundAC.MidiFile_META_SEQUENCE_NAME
    META_INSTRUMENT_NAME = _CsoundAC.MidiFile_META_INSTRUMENT_NAME
    META_LYRIC = _CsoundAC.MidiFile_META_LYRIC
    META_MARKER = _CsoundAC.MidiFile_META_MARKER
    META_CUE_POINT = _CsoundAC.MidiFile_META_CUE_POINT
    META_CHANNEL_PREFIX = _CsoundAC.MidiFile_META_CHANNEL_PREFIX
    META_END_OF_TRACK = _CsoundAC.MidiFile_META_END_OF_TRACK
    META_SET_TEMPO = _CsoundAC.MidiFile_META_SET_TEMPO
    META_SMPTE_OFFSET = _CsoundAC.MidiFile_META_SMPTE_OFFSET
    META_TIME_SIGNATURE = _CsoundAC.MidiFile_META_TIME_SIGNATURE
    META_KEY_SIGNATURE = _CsoundAC.MidiFile_META_KEY_SIGNATURE
    META_SEQUENCER_SPECIFIC = _CsoundAC.MidiFile_META_SEQUENCER_SPECIFIC
    CONTROLLER_MOD_WHEEL = _CsoundAC.MidiFile_CONTROLLER_MOD_WHEEL
    CONTROLLER_BREATH = _CsoundAC.MidiFile_CONTROLLER_BREATH
    CONTROLLER_FOOT = _CsoundAC.MidiFile_CONTROLLER_FOOT
    CONTROLLER_BALANCE = _CsoundAC.MidiFile_CONTROLLER_BALANCE
    CONTROLLER_PAN = _CsoundAC.MidiFile_CONTROLLER_PAN
    CONTROLLER_EXPRESSION = _CsoundAC.MidiFile_CONTROLLER_EXPRESSION
    CONTROLLER_DAMPER_PEDAL = _CsoundAC.MidiFile_CONTROLLER_DAMPER_PEDAL
    CONTROLLER_PORTAMENTO = _CsoundAC.MidiFile_CONTROLLER_PORTAMENTO
    CONTROLLER_SOSTENUTO = _CsoundAC.MidiFile_CONTROLLER_SOSTENUTO
    CONTROLLER_SOFT_PEDAL = _CsoundAC.MidiFile_CONTROLLER_SOFT_PEDAL
    CONTROLLER_GENERAL_4 = _CsoundAC.MidiFile_CONTROLLER_GENERAL_4
    CONTROLLER_HOLD_2 = _CsoundAC.MidiFile_CONTROLLER_HOLD_2
    CONTROLLER_7GENERAL_5 = _CsoundAC.MidiFile_CONTROLLER_7GENERAL_5
    CONTROLLER_GENERAL_6 = _CsoundAC.MidiFile_CONTROLLER_GENERAL_6
    CONTROLLER_GENERAL_7 = _CsoundAC.MidiFile_CONTROLLER_GENERAL_7
    CONTROLLER_GENERAL_8 = _CsoundAC.MidiFile_CONTROLLER_GENERAL_8
    CONTROLLER_TREMOLO_DEPTH = _CsoundAC.MidiFile_CONTROLLER_TREMOLO_DEPTH
    CONTROLLER_CHORUS_DEPTH = _CsoundAC.MidiFile_CONTROLLER_CHORUS_DEPTH
    CONTROLLER_DETUNE = _CsoundAC.MidiFile_CONTROLLER_DETUNE
    CONTROLLER_PHASER_DEPTH = _CsoundAC.MidiFile_CONTROLLER_PHASER_DEPTH
    CONTROLLER_DATA_INC = _CsoundAC.MidiFile_CONTROLLER_DATA_INC
    CONTROLLER_DATA_DEC = _CsoundAC.MidiFile_CONTROLLER_DATA_DEC
    CONTROLLER_NON_REG_LSB = _CsoundAC.MidiFile_CONTROLLER_NON_REG_LSB
    CONTROLLER_NON_REG_MSB = _CsoundAC.MidiFile_CONTROLLER_NON_REG_MSB
    CONTROLLER_REG_LSB = _CsoundAC.MidiFile_CONTROLLER_REG_LSB
    CONTROLLER_REG_MSG = _CsoundAC.MidiFile_CONTROLLER_REG_MSG
    CONTROLLER_CONTINUOUS_AFTERTOUCH = _CsoundAC.MidiFile_CONTROLLER_CONTINUOUS_AFTERTOUCH

    def readVariableLength(stream):
        """readVariableLength(std::istream & stream) -> int"""
        return _CsoundAC.MidiFile_readVariableLength(stream)

    readVariableLength = staticmethod(readVariableLength)

    def writeVariableLength(stream, value):
        """writeVariableLength(std::ostream & stream, int value)"""
        return _CsoundAC.MidiFile_writeVariableLength(stream, value)

    writeVariableLength = staticmethod(writeVariableLength)

    def toInt(c1, c2, c3, c4):
        """toInt(int c1, int c2, int c3, int c4) -> int"""
        return _CsoundAC.MidiFile_toInt(c1, c2, c3, c4)

    toInt = staticmethod(toInt)

    def toShort(c1, c2):
        """toShort(int c1, int c2) -> short"""
        return _CsoundAC.MidiFile_toShort(c1, c2)

    toShort = staticmethod(toShort)

    def readInt(stream):
        """readInt(std::istream & stream) -> int"""
        return _CsoundAC.MidiFile_readInt(stream)

    readInt = staticmethod(readInt)

    def writeInt(stream, value):
        """writeInt(std::ostream & stream, int value)"""
        return _CsoundAC.MidiFile_writeInt(stream, value)

    writeInt = staticmethod(writeInt)

    def readShort(stream):
        """readShort(std::istream & stream) -> short"""
        return _CsoundAC.MidiFile_readShort(stream)

    readShort = staticmethod(readShort)

    def writeShort(stream, value):
        """writeShort(std::ostream & stream, short value)"""
        return _CsoundAC.MidiFile_writeShort(stream, value)

    writeShort = staticmethod(writeShort)

    def chunkName(a, b, c, d):
        """chunkName(int a, int b, int c, int d) -> int"""
        return _CsoundAC.MidiFile_chunkName(a, b, c, d)

    chunkName = staticmethod(chunkName)

    def computeTimes(self):
        """computeTimes(MidiFile self)"""
        return _CsoundAC.MidiFile_computeTimes(self)

    __swig_setmethods__["currentTick"] = _CsoundAC.MidiFile_currentTick_set
    __swig_getmethods__["currentTick"] = _CsoundAC.MidiFile_currentTick_get
    if _newclass:
        currentTick = _swig_property(_CsoundAC.MidiFile_currentTick_get, _CsoundAC.MidiFile_currentTick_set)
    __swig_setmethods__["currentTime"] = _CsoundAC.MidiFile_currentTime_set
    __swig_getmethods__["currentTime"] = _CsoundAC.MidiFile_currentTime_get
    if _newclass:
        currentTime = _swig_property(_CsoundAC.MidiFile_currentTime_get, _CsoundAC.MidiFile_currentTime_set)
    __swig_setmethods__["currentSecondsPerTick"] = _CsoundAC.MidiFile_currentSecondsPerTick_set
    __swig_getmethods__["currentSecondsPerTick"] = _CsoundAC.MidiFile_currentSecondsPerTick_get
    if _newclass:
        currentSecondsPerTick = _swig_property(_CsoundAC.MidiFile_currentSecondsPerTick_get, _CsoundAC.MidiFile_currentSecondsPerTick_set)
    __swig_setmethods__["microsecondsPerQuarterNote"] = _CsoundAC.MidiFile_microsecondsPerQuarterNote_set
    __swig_getmethods__["microsecondsPerQuarterNote"] = _CsoundAC.MidiFile_microsecondsPerQuarterNote_get
    if _newclass:
        microsecondsPerQuarterNote = _swig_property(_CsoundAC.MidiFile_microsecondsPerQuarterNote_get, _CsoundAC.MidiFile_microsecondsPerQuarterNote_set)
    __swig_setmethods__["lastStatus"] = _CsoundAC.MidiFile_lastStatus_set
    __swig_getmethods__["lastStatus"] = _CsoundAC.MidiFile_lastStatus_get
    if _newclass:
        lastStatus = _swig_property(_CsoundAC.MidiFile_lastStatus_get, _CsoundAC.MidiFile_lastStatus_set)
    __swig_setmethods__["midiHeader"] = _CsoundAC.MidiFile_midiHeader_set
    __swig_getmethods__["midiHeader"] = _CsoundAC.MidiFile_midiHeader_get
    if _newclass:
        midiHeader = _swig_property(_CsoundAC.MidiFile_midiHeader_get, _CsoundAC.MidiFile_midiHeader_set)
    __swig_setmethods__["tempoMap"] = _CsoundAC.MidiFile_tempoMap_set
    __swig_getmethods__["tempoMap"] = _CsoundAC.MidiFile_tempoMap_get
    if _newclass:
        tempoMap = _swig_property(_CsoundAC.MidiFile_tempoMap_get, _CsoundAC.MidiFile_tempoMap_set)
    __swig_setmethods__["midiTracks"] = _CsoundAC.MidiFile_midiTracks_set
    __swig_getmethods__["midiTracks"] = _CsoundAC.MidiFile_midiTracks_get
    if _newclass:
        midiTracks = _swig_property(_CsoundAC.MidiFile_midiTracks_get, _CsoundAC.MidiFile_midiTracks_set)

    def __init__(self):
        """__init__(csound::MidiFile self) -> MidiFile"""
        this = _CsoundAC.new_MidiFile()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MidiFile
    __del__ = lambda self: None

    def clear(self):
        """clear(MidiFile self)"""
        return _CsoundAC.MidiFile_clear(self)


    def read(self, stream):
        """read(MidiFile self, std::istream & stream)"""
        return _CsoundAC.MidiFile_read(self, stream)


    def write(self, stream):
        """write(MidiFile self, std::ostream & stream)"""
        return _CsoundAC.MidiFile_write(self, stream)


    def load(self, filename):
        """load(MidiFile self, std::string filename)"""
        return _CsoundAC.MidiFile_load(self, filename)


    def save(self, filename):
        """save(MidiFile self, std::string filename)"""
        return _CsoundAC.MidiFile_save(self, filename)


    def dump(self, stream):
        """dump(MidiFile self, std::ostream & stream)"""
        return _CsoundAC.MidiFile_dump(self, stream)

MidiFile_swigregister = _CsoundAC.MidiFile_swigregister
MidiFile_swigregister(MidiFile)

def MidiFile_readVariableLength(stream):
    """MidiFile_readVariableLength(std::istream & stream) -> int"""
    return _CsoundAC.MidiFile_readVariableLength(stream)

def MidiFile_writeVariableLength(stream, value):
    """MidiFile_writeVariableLength(std::ostream & stream, int value)"""
    return _CsoundAC.MidiFile_writeVariableLength(stream, value)

def MidiFile_toInt(c1, c2, c3, c4):
    """MidiFile_toInt(int c1, int c2, int c3, int c4) -> int"""
    return _CsoundAC.MidiFile_toInt(c1, c2, c3, c4)

def MidiFile_toShort(c1, c2):
    """MidiFile_toShort(int c1, int c2) -> short"""
    return _CsoundAC.MidiFile_toShort(c1, c2)

def MidiFile_readInt(stream):
    """MidiFile_readInt(std::istream & stream) -> int"""
    return _CsoundAC.MidiFile_readInt(stream)

def MidiFile_writeInt(stream, value):
    """MidiFile_writeInt(std::ostream & stream, int value)"""
    return _CsoundAC.MidiFile_writeInt(stream, value)

def MidiFile_readShort(stream):
    """MidiFile_readShort(std::istream & stream) -> short"""
    return _CsoundAC.MidiFile_readShort(stream)

def MidiFile_writeShort(stream, value):
    """MidiFile_writeShort(std::ostream & stream, short value)"""
    return _CsoundAC.MidiFile_writeShort(stream, value)

def MidiFile_chunkName(a, b, c, d):
    """MidiFile_chunkName(int a, int b, int c, int d) -> int"""
    return _CsoundAC.MidiFile_chunkName(a, b, c, d)

class MidiEventComparator(_object):
    """Proxy of C++ csound::MidiEventComparator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MidiEventComparator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MidiEventComparator, name)
    __repr__ = _swig_repr

    def __call__(self, a, b):
        """__call__(MidiEventComparator self, MidiEvent a, MidiEvent b) -> bool"""
        return _CsoundAC.MidiEventComparator___call__(self, a, b)


    def __init__(self):
        """__init__(csound::MidiEventComparator self) -> MidiEventComparator"""
        this = _CsoundAC.new_MidiEventComparator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MidiEventComparator
    __del__ = lambda self: None
MidiEventComparator_swigregister = _CsoundAC.MidiEventComparator_swigregister
MidiEventComparator_swigregister(MidiEventComparator)

class Score(EventVector):
    """Proxy of C++ csound::Score class."""

    __swig_setmethods__ = {}
    for _s in [EventVector]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Score, name, value)
    __swig_getmethods__ = {}
    for _s in [EventVector]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Score, name)
    __repr__ = _swig_repr
    __swig_setmethods__["scaleTargetMinima"] = _CsoundAC.Score_scaleTargetMinima_set
    __swig_getmethods__["scaleTargetMinima"] = _CsoundAC.Score_scaleTargetMinima_get
    if _newclass:
        scaleTargetMinima = _swig_property(_CsoundAC.Score_scaleTargetMinima_get, _CsoundAC.Score_scaleTargetMinima_set)
    __swig_setmethods__["rescaleMinima"] = _CsoundAC.Score_rescaleMinima_set
    __swig_getmethods__["rescaleMinima"] = _CsoundAC.Score_rescaleMinima_get
    if _newclass:
        rescaleMinima = _swig_property(_CsoundAC.Score_rescaleMinima_get, _CsoundAC.Score_rescaleMinima_set)
    __swig_setmethods__["scaleTargetRanges"] = _CsoundAC.Score_scaleTargetRanges_set
    __swig_getmethods__["scaleTargetRanges"] = _CsoundAC.Score_scaleTargetRanges_get
    if _newclass:
        scaleTargetRanges = _swig_property(_CsoundAC.Score_scaleTargetRanges_get, _CsoundAC.Score_scaleTargetRanges_set)
    __swig_setmethods__["rescaleRanges"] = _CsoundAC.Score_rescaleRanges_set
    __swig_getmethods__["rescaleRanges"] = _CsoundAC.Score_rescaleRanges_get
    if _newclass:
        rescaleRanges = _swig_property(_CsoundAC.Score_rescaleRanges_get, _CsoundAC.Score_rescaleRanges_set)
    __swig_setmethods__["scaleActualMinima"] = _CsoundAC.Score_scaleActualMinima_set
    __swig_getmethods__["scaleActualMinima"] = _CsoundAC.Score_scaleActualMinima_get
    if _newclass:
        scaleActualMinima = _swig_property(_CsoundAC.Score_scaleActualMinima_get, _CsoundAC.Score_scaleActualMinima_set)
    __swig_setmethods__["scaleActualRanges"] = _CsoundAC.Score_scaleActualRanges_set
    __swig_getmethods__["scaleActualRanges"] = _CsoundAC.Score_scaleActualRanges_get
    if _newclass:
        scaleActualRanges = _swig_property(_CsoundAC.Score_scaleActualRanges_get, _CsoundAC.Score_scaleActualRanges_set)
    __swig_setmethods__["midifile"] = _CsoundAC.Score_midifile_set
    __swig_getmethods__["midifile"] = _CsoundAC.Score_midifile_get
    if _newclass:
        midifile = _swig_property(_CsoundAC.Score_midifile_get, _CsoundAC.Score_midifile_set)
    __swig_setmethods__["reassignments"] = _CsoundAC.Score_reassignments_set
    __swig_getmethods__["reassignments"] = _CsoundAC.Score_reassignments_get
    if _newclass:
        reassignments = _swig_property(_CsoundAC.Score_reassignments_get, _CsoundAC.Score_reassignments_set)
    __swig_setmethods__["gains"] = _CsoundAC.Score_gains_set
    __swig_getmethods__["gains"] = _CsoundAC.Score_gains_get
    if _newclass:
        gains = _swig_property(_CsoundAC.Score_gains_get, _CsoundAC.Score_gains_set)
    __swig_setmethods__["pans"] = _CsoundAC.Score_pans_set
    __swig_getmethods__["pans"] = _CsoundAC.Score_pans_get
    if _newclass:
        pans = _swig_property(_CsoundAC.Score_pans_get, _CsoundAC.Score_pans_set)

    def __init__(self):
        """__init__(csound::Score self) -> Score"""
        this = _CsoundAC.new_Score()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Score
    __del__ = lambda self: None

    def initialize(self):
        """initialize(Score self)"""
        return _CsoundAC.Score_initialize(self)


    def append(self, *args):
        """
        append(Score self, Event event)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity, double phase=0, double pan=0, double depth=0, double height=0, double pitches=4095)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity, double phase=0, double pan=0, double depth=0, double height=0)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity, double phase=0, double pan=0, double depth=0)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity, double phase=0, double pan=0)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity, double phase=0)
        append(Score self, double time, double duration, double status, double channel, double key, double velocity)
        """
        return _CsoundAC.Score_append(self, *args)


    def remove(self, index):
        """remove(Score self, size_t index)"""
        return _CsoundAC.Score_remove(self, index)


    def load(self, *args):
        """
        load(Score self, std::string filename)
        load(Score self, std::istream & stream)
        """
        return _CsoundAC.Score_load(self, *args)


    def save(self, *args):
        """
        save(Score self, std::string filename)
        save(Score self, std::ostream & stream)
        """
        return _CsoundAC.Score_save(self, *args)


    def getScale(score, dimension, beginAt, endAt, minimum, range):
        """getScale(EventVector score, int dimension, size_t beginAt, size_t endAt, double & minimum, double & range)"""
        return _CsoundAC.Score_getScale(score, dimension, beginAt, endAt, minimum, range)

    getScale = staticmethod(getScale)

    def setScale(score, dimension, rescaleMinimum, rescaleRange, beginAt, endAt, targetMinimum, targetRange):
        """setScale(EventVector score, int dimension, bool rescaleMinimum, bool rescaleRange, size_t beginAt, size_t endAt, double targetMinimum, double targetRange)"""
        return _CsoundAC.Score_setScale(score, dimension, rescaleMinimum, rescaleRange, beginAt, endAt, targetMinimum, targetRange)

    setScale = staticmethod(setScale)

    def findScale(self):
        """findScale(Score self)"""
        return _CsoundAC.Score_findScale(self)


    def sort(self):
        """sort(Score self)"""
        return _CsoundAC.Score_sort(self)


    def dump(self, stream):
        """dump(Score self, std::ostream & stream)"""
        return _CsoundAC.Score_dump(self, stream)


    def toString(self):
        """toString(Score self) -> std::string"""
        return _CsoundAC.Score_toString(self)


    def getDuration(self):
        """getDuration(Score self) -> double"""
        return _CsoundAC.Score_getDuration(self)


    def rescale(self, *args):
        """
        rescale(Score self)
        rescale(Score self, Event event)
        rescale(Score self, int dimension, bool rescaleMinimum, double minimum, bool rescaleRange=False, double range=0.0)
        rescale(Score self, int dimension, bool rescaleMinimum, double minimum, bool rescaleRange=False)
        rescale(Score self, int dimension, bool rescaleMinimum, double minimum)
        """
        return _CsoundAC.Score_rescale(self, *args)


    def getCsoundScore(self, tonesPerOctave=12.0, conformPitches=False):
        """
        getCsoundScore(Score self, double tonesPerOctave=12.0, bool conformPitches=False) -> std::string
        getCsoundScore(Score self, double tonesPerOctave=12.0) -> std::string
        getCsoundScore(Score self) -> std::string
        """
        return _CsoundAC.Score_getCsoundScore(self, tonesPerOctave, conformPitches)


    def arrange(self, *args):
        """
        arrange(Score self, int oldInstrumentNumber, int newInstrumentNumber)
        arrange(Score self, int oldInstrumentNumber, int newInstrumentNumber, double gain)
        arrange(Score self, int oldInstrumentNumber, int newInstrumentNumber, double gain, double pan)
        """
        return _CsoundAC.Score_arrange(self, *args)


    def removeArrangement(self):
        """removeArrangement(Score self)"""
        return _CsoundAC.Score_removeArrangement(self)


    def getPitches(self, begin, end, divisionsPerOctave=12):
        """
        getPitches(Score self, size_t begin, size_t end, size_t divisionsPerOctave=12) -> DoubleVector
        getPitches(Score self, size_t begin, size_t end) -> DoubleVector
        """
        return _CsoundAC.Score_getPitches(self, begin, end, divisionsPerOctave)


    def setPitches(self, begin, end, pitches):
        """setPitches(Score self, size_t begin, size_t end, DoubleVector pitches)"""
        return _CsoundAC.Score_setPitches(self, begin, end, pitches)


    def setPitchClassSet(self, begin, end, pcs, divisionsPerOctave=12):
        """
        setPitchClassSet(Score self, size_t begin, size_t end, DoubleVector pcs, size_t divisionsPerOctave=12)
        setPitchClassSet(Score self, size_t begin, size_t end, DoubleVector pcs)
        """
        return _CsoundAC.Score_setPitchClassSet(self, begin, end, pcs, divisionsPerOctave)


    def getPTV(self, begin, end, lowest, range, divisionsPerOctave=12):
        """
        getPTV(Score self, size_t begin, size_t end, double lowest, double range, size_t divisionsPerOctave=12) -> DoubleVector
        getPTV(Score self, size_t begin, size_t end, double lowest, double range) -> DoubleVector
        """
        return _CsoundAC.Score_getPTV(self, begin, end, lowest, range, divisionsPerOctave)


    def setPTV(self, begin, end, prime, transposition, voicing, lowest, range, divisionsPerOctave=12):
        """
        setPTV(Score self, size_t begin, size_t end, double prime, double transposition, double voicing, double lowest, double range, size_t divisionsPerOctave=12)
        setPTV(Score self, size_t begin, size_t end, double prime, double transposition, double voicing, double lowest, double range)
        """
        return _CsoundAC.Score_setPTV(self, begin, end, prime, transposition, voicing, lowest, range, divisionsPerOctave)


    def getPT(self, begin, end, lowest, range, divisionsPerOctave=12):
        """
        getPT(Score self, size_t begin, size_t end, double lowest, double range, size_t divisionsPerOctave=12) -> DoubleVector
        getPT(Score self, size_t begin, size_t end, double lowest, double range) -> DoubleVector
        """
        return _CsoundAC.Score_getPT(self, begin, end, lowest, range, divisionsPerOctave)


    def setPT(self, begin, end, prime, transposition, lowest, range, divisionsPerOctave=12):
        """
        setPT(Score self, size_t begin, size_t end, double prime, double transposition, double lowest, double range, size_t divisionsPerOctave=12)
        setPT(Score self, size_t begin, size_t end, double prime, double transposition, double lowest, double range)
        """
        return _CsoundAC.Score_setPT(self, begin, end, prime, transposition, lowest, range, divisionsPerOctave)


    def voicelead(self, *args):
        """
        voicelead(Score self, size_t beginSource, size_t endSource, size_t beginTarget, size_t endTarget, double lowest, double range, bool avoidParallelFifths, size_t divisionsPerOctave=12)
        voicelead(Score self, size_t beginSource, size_t endSource, size_t beginTarget, size_t endTarget, double lowest, double range, bool avoidParallelFifths)
        voicelead(Score self, size_t beginSource, size_t endSource, size_t beginTarget, size_t endTarget, DoubleVector targetPitches, double lowest, double range, bool avoidParallelFifths, size_t divisionsPerOctave=12)
        voicelead(Score self, size_t beginSource, size_t endSource, size_t beginTarget, size_t endTarget, DoubleVector targetPitches, double lowest, double range, bool avoidParallelFifths)
        """
        return _CsoundAC.Score_voicelead(self, *args)


    def indexAtTime(self, time):
        """indexAtTime(Score self, double time) -> int"""
        return _CsoundAC.Score_indexAtTime(self, time)


    def indexAfterTime(self, time):
        """indexAfterTime(Score self, double time) -> int"""
        return _CsoundAC.Score_indexAfterTime(self, time)


    def indexToTime(self, index):
        """indexToTime(Score self, size_t index) -> double"""
        return _CsoundAC.Score_indexToTime(self, index)


    def getVoicing(self, begin, end, divisionsPerOctave=12):
        """
        getVoicing(Score self, size_t begin, size_t end, size_t divisionsPerOctave=12) -> DoubleVector
        getVoicing(Score self, size_t begin, size_t end) -> DoubleVector
        """
        return _CsoundAC.Score_getVoicing(self, begin, end, divisionsPerOctave)


    def setVoicing(self, begin, end, voicing, range, divisionsPerOctave=12):
        """
        setVoicing(Score self, size_t begin, size_t end, DoubleVector voicing, double range, size_t divisionsPerOctave=12)
        setVoicing(Score self, size_t begin, size_t end, DoubleVector voicing, double range)
        """
        return _CsoundAC.Score_setVoicing(self, begin, end, voicing, range, divisionsPerOctave)


    def setK(self, priorBegin, begin, end, base, range):
        """setK(Score self, size_t priorBegin, size_t begin, size_t end, double base, double range)"""
        return _CsoundAC.Score_setK(self, priorBegin, begin, end, base, range)


    def setKV(self, priorBegin, begin, end, V, base, range):
        """setKV(Score self, size_t priorBegin, size_t begin, size_t end, double V, double base, double range)"""
        return _CsoundAC.Score_setKV(self, priorBegin, begin, end, V, base, range)


    def setKL(self, priorBegin, begin, end, base, range, avoidParallels=True):
        """
        setKL(Score self, size_t priorBegin, size_t begin, size_t end, double base, double range, bool avoidParallels=True)
        setKL(Score self, size_t priorBegin, size_t begin, size_t end, double base, double range)
        """
        return _CsoundAC.Score_setKL(self, priorBegin, begin, end, base, range, avoidParallels)


    def setQ(self, priorBegin, begin, end, Q, context, base, range):
        """setQ(Score self, size_t priorBegin, size_t begin, size_t end, double Q, DoubleVector context, double base, double range)"""
        return _CsoundAC.Score_setQ(self, priorBegin, begin, end, Q, context, base, range)


    def setQV(self, priorBegin, begin, end, Q, context, V, base, range):
        """setQV(Score self, size_t priorBegin, size_t begin, size_t end, double Q, DoubleVector context, double V, double base, double range)"""
        return _CsoundAC.Score_setQV(self, priorBegin, begin, end, Q, context, V, base, range)


    def setQL(self, priorBegin, begin, end, Q, context, base, range, avoidParallels=True):
        """
        setQL(Score self, size_t priorBegin, size_t begin, size_t end, double Q, DoubleVector context, double base, double range, bool avoidParallels=True)
        setQL(Score self, size_t priorBegin, size_t begin, size_t end, double Q, DoubleVector context, double base, double range)
        """
        return _CsoundAC.Score_setQL(self, priorBegin, begin, end, Q, context, base, range, avoidParallels)


    def setDuration(self, targetDuration):
        """setDuration(Score self, double targetDuration)"""
        return _CsoundAC.Score_setDuration(self, targetDuration)


    def tieOverlappingNotes(self, considerInstrumentNumber=False):
        """
        tieOverlappingNotes(Score self, bool considerInstrumentNumber=False)
        tieOverlappingNotes(Score self)
        """
        return _CsoundAC.Score_tieOverlappingNotes(self, considerInstrumentNumber)


    def temper(self, tonesPerOctave=12.0):
        """
        temper(Score self, double tonesPerOctave=12.0)
        temper(Score self)
        """
        return _CsoundAC.Score_temper(self, tonesPerOctave)

Score_swigregister = _CsoundAC.Score_swigregister
Score_swigregister(Score)

def Score_getScale(score, dimension, beginAt, endAt, minimum, range):
    """Score_getScale(EventVector score, int dimension, size_t beginAt, size_t endAt, double & minimum, double & range)"""
    return _CsoundAC.Score_getScale(score, dimension, beginAt, endAt, minimum, range)

def Score_setScale(score, dimension, rescaleMinimum, rescaleRange, beginAt, endAt, targetMinimum, targetRange):
    """Score_setScale(EventVector score, int dimension, bool rescaleMinimum, bool rescaleRange, size_t beginAt, size_t endAt, double targetMinimum, double targetRange)"""
    return _CsoundAC.Score_setScale(score, dimension, rescaleMinimum, rescaleRange, beginAt, endAt, targetMinimum, targetRange)

class Composition(_object):
    """Proxy of C++ csound::Composition class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Composition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Composition, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Composition self) -> Composition"""
        this = _CsoundAC.new_Composition()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Composition
    __del__ = lambda self: None

    def getOutputDirectory(self):
        """getOutputDirectory(Composition self) -> std::string"""
        return _CsoundAC.Composition_getOutputDirectory(self)


    def setOutputDirectory(self, directory):
        """setOutputDirectory(Composition self, std::string directory)"""
        return _CsoundAC.Composition_setOutputDirectory(self, directory)


    def getFilename(self):
        """getFilename(Composition self) -> std::string"""
        return _CsoundAC.Composition_getFilename(self)


    def setFilename(self, filename):
        """setFilename(Composition self, std::string filename)"""
        return _CsoundAC.Composition_setFilename(self, filename)


    def getFilePathname(self):
        """getFilePathname(Composition self) -> std::string"""
        return _CsoundAC.Composition_getFilePathname(self)


    def generateFilename():
        """generateFilename() -> std::string"""
        return _CsoundAC.Composition_generateFilename()

    generateFilename = staticmethod(generateFilename)

    def makeTimestamp():
        """makeTimestamp() -> std::string"""
        return _CsoundAC.Composition_makeTimestamp()

    makeTimestamp = staticmethod(makeTimestamp)

    def getTimestamp(self):
        """getTimestamp(Composition self) -> std::string"""
        return _CsoundAC.Composition_getTimestamp(self)


    def getOutputSoundfileName(self):
        """getOutputSoundfileName(Composition self) -> std::string"""
        return _CsoundAC.Composition_getOutputSoundfileName(self)


    def getNormalizedSoundfileName(self):
        """getNormalizedSoundfileName(Composition self) -> std::string"""
        return _CsoundAC.Composition_getNormalizedSoundfileName(self)


    def getCdSoundfileName(self):
        """getCdSoundfileName(Composition self) -> std::string"""
        return _CsoundAC.Composition_getCdSoundfileName(self)


    def getMp3SoundfileName(self):
        """getMp3SoundfileName(Composition self) -> std::string"""
        return _CsoundAC.Composition_getMp3SoundfileName(self)


    def getMidiFilename(self):
        """getMidiFilename(Composition self) -> std::string"""
        return _CsoundAC.Composition_getMidiFilename(self)


    def getMusicXmlFilename(self):
        """getMusicXmlFilename(Composition self) -> std::string"""
        return _CsoundAC.Composition_getMusicXmlFilename(self)


    def getFomusFilename(self):
        """getFomusFilename(Composition self) -> std::string"""
        return _CsoundAC.Composition_getFomusFilename(self)


    def getLilypondFilename(self):
        """getLilypondFilename(Composition self) -> std::string"""
        return _CsoundAC.Composition_getLilypondFilename(self)


    def generate(self):
        """generate(Composition self) -> int"""
        return _CsoundAC.Composition_generate(self)


    def render(self):
        """render(Composition self) -> int"""
        return _CsoundAC.Composition_render(self)


    def renderAll(self):
        """renderAll(Composition self) -> int"""
        return _CsoundAC.Composition_renderAll(self)


    def perform(self):
        """perform(Composition self) -> int"""
        return _CsoundAC.Composition_perform(self)


    def performMaster(self):
        """performMaster(Composition self) -> int"""
        return _CsoundAC.Composition_performMaster(self)


    def translateMaster(self):
        """translateMaster(Composition self) -> int"""
        return _CsoundAC.Composition_translateMaster(self)


    def performAll(self):
        """performAll(Composition self) -> int"""
        return _CsoundAC.Composition_performAll(self)


    def normalizeOutputSoundfile(self, levelDb=-3.0):
        """
        normalizeOutputSoundfile(Composition self, double levelDb=-3.0) -> int
        normalizeOutputSoundfile(Composition self) -> int
        """
        return _CsoundAC.Composition_normalizeOutputSoundfile(self, levelDb)


    def translateToCdAudio(self, levelDb=-3.0):
        """
        translateToCdAudio(Composition self, double levelDb=-3.0) -> int
        translateToCdAudio(Composition self) -> int
        """
        return _CsoundAC.Composition_translateToCdAudio(self, levelDb)


    def translateToMp3(self, bitrate=256.01, levelDb=-3.0):
        """
        translateToMp3(Composition self, double bitrate=256.01, double levelDb=-3.0) -> int
        translateToMp3(Composition self, double bitrate=256.01) -> int
        translateToMp3(Composition self) -> int
        """
        return _CsoundAC.Composition_translateToMp3(self, bitrate, levelDb)


    def clear(self):
        """clear(Composition self)"""
        return _CsoundAC.Composition_clear(self)


    def getScore(self):
        """getScore(Composition self) -> Score"""
        return _CsoundAC.Composition_getScore(self)


    def write(self, text):
        """write(Composition self, char const * text)"""
        return _CsoundAC.Composition_write(self, text)


    def setTonesPerOctave(self, tonesPerOctave):
        """setTonesPerOctave(Composition self, double tonesPerOctave)"""
        return _CsoundAC.Composition_setTonesPerOctave(self, tonesPerOctave)


    def getTonesPerOctave(self):
        """getTonesPerOctave(Composition self) -> double"""
        return _CsoundAC.Composition_getTonesPerOctave(self)


    def setConformPitches(self, conformPitches):
        """setConformPitches(Composition self, bool conformPitches)"""
        return _CsoundAC.Composition_setConformPitches(self, conformPitches)


    def getConformPitches(self):
        """getConformPitches(Composition self) -> bool"""
        return _CsoundAC.Composition_getConformPitches(self)


    def translateToNotation(self, *args):
        """
        translateToNotation(Composition self, std::vector< std::string,std::allocator< std::string > > const partNames, std::string header) -> int
        translateToNotation(Composition self, std::vector< std::string,std::allocator< std::string > > const partNames) -> int
        translateToNotation(Composition self) -> int
        """
        return _CsoundAC.Composition_translateToNotation(self, *args)


    def getArtist(self):
        """getArtist(Composition self) -> std::string"""
        return _CsoundAC.Composition_getArtist(self)


    def setArtist(self, value):
        """setArtist(Composition self, std::string value)"""
        return _CsoundAC.Composition_setArtist(self, value)


    def getTitle(self):
        """getTitle(Composition self) -> std::string"""
        return _CsoundAC.Composition_getTitle(self)


    def setTitle(self, value):
        """setTitle(Composition self, std::string value)"""
        return _CsoundAC.Composition_setTitle(self, value)


    def getCopyright(self):
        """getCopyright(Composition self) -> std::string"""
        return _CsoundAC.Composition_getCopyright(self)


    def setCopyright(self, value):
        """setCopyright(Composition self, std::string value)"""
        return _CsoundAC.Composition_setCopyright(self, value)


    def getAlbum(self):
        """getAlbum(Composition self) -> std::string"""
        return _CsoundAC.Composition_getAlbum(self)


    def setAlbum(self, value):
        """setAlbum(Composition self, std::string value)"""
        return _CsoundAC.Composition_setAlbum(self, value)


    def getLicense(self):
        """getLicense(Composition self) -> std::string"""
        return _CsoundAC.Composition_getLicense(self)


    def setLicense(self, value):
        """setLicense(Composition self, std::string value)"""
        return _CsoundAC.Composition_setLicense(self, value)


    def tagFile(self, filename):
        """tagFile(Composition self, std::string filename) -> int"""
        return _CsoundAC.Composition_tagFile(self, filename)


    def processArgv(self, argc, argv):
        """processArgv(Composition self, int argc, char const ** argv) -> int"""
        return _CsoundAC.Composition_processArgv(self, argc, argv)


    def processArgs(self, args):
        """processArgs(Composition self, std::vector< std::string,std::allocator< std::string > > const & args) -> int"""
        return _CsoundAC.Composition_processArgs(self, args)


    def setOutputSoundfileName(self, name):
        """setOutputSoundfileName(Composition self, std::string name)"""
        return _CsoundAC.Composition_setOutputSoundfileName(self, name)


    def clearOutputSoundfileName(self):
        """clearOutputSoundfileName(Composition self)"""
        return _CsoundAC.Composition_clearOutputSoundfileName(self)

Composition_swigregister = _CsoundAC.Composition_swigregister
Composition_swigregister(Composition)

def Composition_generateFilename():
    """Composition_generateFilename() -> std::string"""
    return _CsoundAC.Composition_generateFilename()

def Composition_makeTimestamp():
    """Composition_makeTimestamp() -> std::string"""
    return _CsoundAC.Composition_makeTimestamp()

class NodeVector(_object):
    """Proxy of C++ std::vector<(p.csound::Node)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NodeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NodeVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(NodeVector self) -> SwigPyIterator"""
        return _CsoundAC.NodeVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(NodeVector self) -> bool"""
        return _CsoundAC.NodeVector___nonzero__(self)


    def __bool__(self):
        """__bool__(NodeVector self) -> bool"""
        return _CsoundAC.NodeVector___bool__(self)


    def __len__(self):
        """__len__(NodeVector self) -> std::vector< csound::Node * >::size_type"""
        return _CsoundAC.NodeVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(NodeVector self, std::vector< csound::Node * >::difference_type i, std::vector< csound::Node * >::difference_type j) -> NodeVector"""
        return _CsoundAC.NodeVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(NodeVector self, std::vector< csound::Node * >::difference_type i, std::vector< csound::Node * >::difference_type j)
        __setslice__(NodeVector self, std::vector< csound::Node * >::difference_type i, std::vector< csound::Node * >::difference_type j, NodeVector v)
        """
        return _CsoundAC.NodeVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(NodeVector self, std::vector< csound::Node * >::difference_type i, std::vector< csound::Node * >::difference_type j)"""
        return _CsoundAC.NodeVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(NodeVector self, std::vector< csound::Node * >::difference_type i)
        __delitem__(NodeVector self, PySliceObject * slice)
        """
        return _CsoundAC.NodeVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(NodeVector self, PySliceObject * slice) -> NodeVector
        __getitem__(NodeVector self, std::vector< csound::Node * >::difference_type i) -> Node
        """
        return _CsoundAC.NodeVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(NodeVector self, PySliceObject * slice, NodeVector v)
        __setitem__(NodeVector self, PySliceObject * slice)
        __setitem__(NodeVector self, std::vector< csound::Node * >::difference_type i, Node x)
        """
        return _CsoundAC.NodeVector___setitem__(self, *args)


    def pop(self):
        """pop(NodeVector self) -> Node"""
        return _CsoundAC.NodeVector_pop(self)


    def append(self, x):
        """append(NodeVector self, Node x)"""
        return _CsoundAC.NodeVector_append(self, x)


    def empty(self):
        """empty(NodeVector self) -> bool"""
        return _CsoundAC.NodeVector_empty(self)


    def size(self):
        """size(NodeVector self) -> std::vector< csound::Node * >::size_type"""
        return _CsoundAC.NodeVector_size(self)


    def swap(self, v):
        """swap(NodeVector self, NodeVector v)"""
        return _CsoundAC.NodeVector_swap(self, v)


    def begin(self):
        """begin(NodeVector self) -> std::vector< csound::Node * >::iterator"""
        return _CsoundAC.NodeVector_begin(self)


    def end(self):
        """end(NodeVector self) -> std::vector< csound::Node * >::iterator"""
        return _CsoundAC.NodeVector_end(self)


    def rbegin(self):
        """rbegin(NodeVector self) -> std::vector< csound::Node * >::reverse_iterator"""
        return _CsoundAC.NodeVector_rbegin(self)


    def rend(self):
        """rend(NodeVector self) -> std::vector< csound::Node * >::reverse_iterator"""
        return _CsoundAC.NodeVector_rend(self)


    def clear(self):
        """clear(NodeVector self)"""
        return _CsoundAC.NodeVector_clear(self)


    def get_allocator(self):
        """get_allocator(NodeVector self) -> std::vector< csound::Node * >::allocator_type"""
        return _CsoundAC.NodeVector_get_allocator(self)


    def pop_back(self):
        """pop_back(NodeVector self)"""
        return _CsoundAC.NodeVector_pop_back(self)


    def erase(self, *args):
        """
        erase(NodeVector self, std::vector< csound::Node * >::iterator pos) -> std::vector< csound::Node * >::iterator
        erase(NodeVector self, std::vector< csound::Node * >::iterator first, std::vector< csound::Node * >::iterator last) -> std::vector< csound::Node * >::iterator
        """
        return _CsoundAC.NodeVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.csound::Node)> self) -> NodeVector
        __init__(std::vector<(p.csound::Node)> self, NodeVector arg2) -> NodeVector
        __init__(std::vector<(p.csound::Node)> self, std::vector< csound::Node * >::size_type size) -> NodeVector
        __init__(std::vector<(p.csound::Node)> self, std::vector< csound::Node * >::size_type size, Node value) -> NodeVector
        """
        this = _CsoundAC.new_NodeVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(NodeVector self, Node x)"""
        return _CsoundAC.NodeVector_push_back(self, x)


    def front(self):
        """front(NodeVector self) -> Node"""
        return _CsoundAC.NodeVector_front(self)


    def back(self):
        """back(NodeVector self) -> Node"""
        return _CsoundAC.NodeVector_back(self)


    def assign(self, n, x):
        """assign(NodeVector self, std::vector< csound::Node * >::size_type n, Node x)"""
        return _CsoundAC.NodeVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(NodeVector self, std::vector< csound::Node * >::size_type new_size)
        resize(NodeVector self, std::vector< csound::Node * >::size_type new_size, Node x)
        """
        return _CsoundAC.NodeVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(NodeVector self, std::vector< csound::Node * >::iterator pos, Node x) -> std::vector< csound::Node * >::iterator
        insert(NodeVector self, std::vector< csound::Node * >::iterator pos, std::vector< csound::Node * >::size_type n, Node x)
        """
        return _CsoundAC.NodeVector_insert(self, *args)


    def reserve(self, n):
        """reserve(NodeVector self, std::vector< csound::Node * >::size_type n)"""
        return _CsoundAC.NodeVector_reserve(self, n)


    def capacity(self):
        """capacity(NodeVector self) -> std::vector< csound::Node * >::size_type"""
        return _CsoundAC.NodeVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_NodeVector
    __del__ = lambda self: None
NodeVector_swigregister = _CsoundAC.NodeVector_swigregister
NodeVector_swigregister(NodeVector)

class Node(_object):
    """Proxy of C++ csound::Node class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    __repr__ = _swig_repr
    __swig_setmethods__["children"] = _CsoundAC.Node_children_set
    __swig_getmethods__["children"] = _CsoundAC.Node_children_get
    if _newclass:
        children = _swig_property(_CsoundAC.Node_children_get, _CsoundAC.Node_children_set)

    def __init__(self):
        """__init__(csound::Node self) -> Node"""
        if self.__class__ == Node:
            _self = None
        else:
            _self = self
        this = _CsoundAC.new_Node(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Node
    __del__ = lambda self: None

    def getLocalCoordinates(self):
        """getLocalCoordinates(Node self) -> Eigen::MatrixXd"""
        return _CsoundAC.Node_getLocalCoordinates(self)


    def traverse(self, globalCoordinates, score):
        """traverse(Node self, Eigen::MatrixXd const & globalCoordinates, Score score) -> Eigen::MatrixXd"""
        return _CsoundAC.Node_traverse(self, globalCoordinates, score)


    def produceOrTransform(self, collectingScore, beginAt, endAt, compositeCordinates):
        """produceOrTransform(Node self, Score collectingScore, size_t beginAt, size_t endAt, Eigen::MatrixXd const & compositeCordinates)"""
        return _CsoundAC.Node_produceOrTransform(self, collectingScore, beginAt, endAt, compositeCordinates)


    def createTransform(self):
        """createTransform(Node self) -> Eigen::MatrixXd"""
        return _CsoundAC.Node_createTransform(self)


    def clear(self):
        """clear(Node self)"""
        return _CsoundAC.Node_clear(self)


    def element(self, row, column):
        """element(Node self, size_t row, size_t column) -> double &"""
        return _CsoundAC.Node_element(self, row, column)


    def setElement(self, row, column, value):
        """setElement(Node self, size_t row, size_t column, double value)"""
        return _CsoundAC.Node_setElement(self, row, column, value)


    def addChild(self, node):
        """addChild(Node self, Node node)"""
        return _CsoundAC.Node_addChild(self, node)

    def __disown__(self):
        self.this.disown()
        _CsoundAC.disown_Node(self)
        return weakref_proxy(self)
Node_swigregister = _CsoundAC.Node_swigregister
Node_swigregister(Node)

class RemoveDuplicates(Node):
    """Proxy of C++ csound::RemoveDuplicates class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveDuplicates, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RemoveDuplicates, name)
    __repr__ = _swig_repr

    def produceOrTransform(self, score, beginAt, endAt, compositeCordinates):
        """produceOrTransform(RemoveDuplicates self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & compositeCordinates)"""
        return _CsoundAC.RemoveDuplicates_produceOrTransform(self, score, beginAt, endAt, compositeCordinates)


    def __init__(self):
        """__init__(csound::RemoveDuplicates self) -> RemoveDuplicates"""
        this = _CsoundAC.new_RemoveDuplicates()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_RemoveDuplicates
    __del__ = lambda self: None
RemoveDuplicates_swigregister = _CsoundAC.RemoveDuplicates_swigregister
RemoveDuplicates_swigregister(RemoveDuplicates)

class Counterpoint(_object):
    """Proxy of C++ Counterpoint class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Counterpoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Counterpoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["messageCallback"] = _CsoundAC.Counterpoint_messageCallback_set
    __swig_getmethods__["messageCallback"] = _CsoundAC.Counterpoint_messageCallback_get
    if _newclass:
        messageCallback = _swig_property(_CsoundAC.Counterpoint_messageCallback_get, _CsoundAC.Counterpoint_messageCallback_set)

    def message(self, format):
        """message(Counterpoint self, char const * format)"""
        return _CsoundAC.Counterpoint_message(self, format)

    __swig_setmethods__["MostNotes"] = _CsoundAC.Counterpoint_MostNotes_set
    __swig_getmethods__["MostNotes"] = _CsoundAC.Counterpoint_MostNotes_get
    if _newclass:
        MostNotes = _swig_property(_CsoundAC.Counterpoint_MostNotes_get, _CsoundAC.Counterpoint_MostNotes_set)
    __swig_setmethods__["MostVoices"] = _CsoundAC.Counterpoint_MostVoices_set
    __swig_getmethods__["MostVoices"] = _CsoundAC.Counterpoint_MostVoices_get
    if _newclass:
        MostVoices = _swig_property(_CsoundAC.Counterpoint_MostVoices_get, _CsoundAC.Counterpoint_MostVoices_set)
    MostNotes_ = _CsoundAC.Counterpoint_MostNotes_
    MostVoices_ = _CsoundAC.Counterpoint_MostVoices_
    __swig_setmethods__["randx"] = _CsoundAC.Counterpoint_randx_set
    __swig_getmethods__["randx"] = _CsoundAC.Counterpoint_randx_get
    if _newclass:
        randx = _swig_property(_CsoundAC.Counterpoint_randx_get, _CsoundAC.Counterpoint_randx_set)
    __swig_setmethods__["Ctrpt"] = _CsoundAC.Counterpoint_Ctrpt_set
    __swig_getmethods__["Ctrpt"] = _CsoundAC.Counterpoint_Ctrpt_get
    if _newclass:
        Ctrpt = _swig_property(_CsoundAC.Counterpoint_Ctrpt_get, _CsoundAC.Counterpoint_Ctrpt_set)
    __swig_setmethods__["Onset"] = _CsoundAC.Counterpoint_Onset_set
    __swig_getmethods__["Onset"] = _CsoundAC.Counterpoint_Onset_get
    if _newclass:
        Onset = _swig_property(_CsoundAC.Counterpoint_Onset_get, _CsoundAC.Counterpoint_Onset_set)
    __swig_setmethods__["Dur"] = _CsoundAC.Counterpoint_Dur_set
    __swig_getmethods__["Dur"] = _CsoundAC.Counterpoint_Dur_get
    if _newclass:
        Dur = _swig_property(_CsoundAC.Counterpoint_Dur_get, _CsoundAC.Counterpoint_Dur_set)
    __swig_setmethods__["TotalNotes"] = _CsoundAC.Counterpoint_TotalNotes_set
    __swig_getmethods__["TotalNotes"] = _CsoundAC.Counterpoint_TotalNotes_get
    if _newclass:
        TotalNotes = _swig_property(_CsoundAC.Counterpoint_TotalNotes_get, _CsoundAC.Counterpoint_TotalNotes_set)
    __swig_setmethods__["BestFit"] = _CsoundAC.Counterpoint_BestFit_set
    __swig_getmethods__["BestFit"] = _CsoundAC.Counterpoint_BestFit_get
    if _newclass:
        BestFit = _swig_property(_CsoundAC.Counterpoint_BestFit_get, _CsoundAC.Counterpoint_BestFit_set)
    __swig_setmethods__["BestFit1"] = _CsoundAC.Counterpoint_BestFit1_set
    __swig_getmethods__["BestFit1"] = _CsoundAC.Counterpoint_BestFit1_get
    if _newclass:
        BestFit1 = _swig_property(_CsoundAC.Counterpoint_BestFit1_get, _CsoundAC.Counterpoint_BestFit1_set)
    __swig_setmethods__["BestFit2"] = _CsoundAC.Counterpoint_BestFit2_set
    __swig_getmethods__["BestFit2"] = _CsoundAC.Counterpoint_BestFit2_get
    if _newclass:
        BestFit2 = _swig_property(_CsoundAC.Counterpoint_BestFit2_get, _CsoundAC.Counterpoint_BestFit2_set)
    __swig_setmethods__["vbs"] = _CsoundAC.Counterpoint_vbs_set
    __swig_getmethods__["vbs"] = _CsoundAC.Counterpoint_vbs_get
    if _newclass:
        vbs = _swig_property(_CsoundAC.Counterpoint_vbs_get, _CsoundAC.Counterpoint_vbs_set)
    __swig_setmethods__["RhyPat"] = _CsoundAC.Counterpoint_RhyPat_set
    __swig_getmethods__["RhyPat"] = _CsoundAC.Counterpoint_RhyPat_get
    if _newclass:
        RhyPat = _swig_property(_CsoundAC.Counterpoint_RhyPat_get, _CsoundAC.Counterpoint_RhyPat_set)
    __swig_setmethods__["RhyNotes"] = _CsoundAC.Counterpoint_RhyNotes_set
    __swig_getmethods__["RhyNotes"] = _CsoundAC.Counterpoint_RhyNotes_get
    if _newclass:
        RhyNotes = _swig_property(_CsoundAC.Counterpoint_RhyNotes_get, _CsoundAC.Counterpoint_RhyNotes_set)
    __swig_setmethods__["Fits"] = _CsoundAC.Counterpoint_Fits_set
    __swig_getmethods__["Fits"] = _CsoundAC.Counterpoint_Fits_get
    if _newclass:
        Fits = _swig_property(_CsoundAC.Counterpoint_Fits_get, _CsoundAC.Counterpoint_Fits_set)

    def initialize(self, mostnotes, mostvoices):
        """initialize(Counterpoint self, int mostnotes, int mostvoices)"""
        return _CsoundAC.Counterpoint_initialize(self, mostnotes, mostvoices)


    def clear(self):
        """clear(Counterpoint self)"""
        return _CsoundAC.Counterpoint_clear(self)


    def __init__(self):
        """__init__(Counterpoint self) -> Counterpoint"""
        this = _CsoundAC.new_Counterpoint()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Counterpoint
    __del__ = lambda self: None

    def ABS(self, i):
        """ABS(Counterpoint self, int i) -> int"""
        return _CsoundAC.Counterpoint_ABS(self, i)


    def MIN(self, a, b):
        """MIN(Counterpoint self, int a, int b) -> int"""
        return _CsoundAC.Counterpoint_MIN(self, a, b)


    def MAX(self, a, b):
        """MAX(Counterpoint self, int a, int b) -> int"""
        return _CsoundAC.Counterpoint_MAX(self, a, b)


    def ARRBLT(self, dest, source, num):
        """ARRBLT(Counterpoint self, int * dest, int * source, int num)"""
        return _CsoundAC.Counterpoint_ARRBLT(self, dest, source, num)

    Unison = _CsoundAC.Counterpoint_Unison
    MinorSecond = _CsoundAC.Counterpoint_MinorSecond
    MajorSecond = _CsoundAC.Counterpoint_MajorSecond
    MinorThird = _CsoundAC.Counterpoint_MinorThird
    MajorThird = _CsoundAC.Counterpoint_MajorThird
    Fourth = _CsoundAC.Counterpoint_Fourth
    Tritone = _CsoundAC.Counterpoint_Tritone
    Fifth = _CsoundAC.Counterpoint_Fifth
    MinorSixth = _CsoundAC.Counterpoint_MinorSixth
    MajorSixth = _CsoundAC.Counterpoint_MajorSixth
    MinorSeventh = _CsoundAC.Counterpoint_MinorSeventh
    MajorSeventh = _CsoundAC.Counterpoint_MajorSeventh
    Octave = _CsoundAC.Counterpoint_Octave
    Aeolian = _CsoundAC.Counterpoint_Aeolian
    Dorian = _CsoundAC.Counterpoint_Dorian
    Phrygian = _CsoundAC.Counterpoint_Phrygian
    Lydian = _CsoundAC.Counterpoint_Lydian
    Mixolydian = _CsoundAC.Counterpoint_Mixolydian
    Ionian = _CsoundAC.Counterpoint_Ionian
    Locrian = _CsoundAC.Counterpoint_Locrian

    def InMode(self, Pitch, Mode):
        """InMode(Counterpoint self, int Pitch, int Mode) -> int"""
        return _CsoundAC.Counterpoint_InMode(self, Pitch, Mode)


    def BadMelody(self, Intv):
        """BadMelody(Counterpoint self, int Intv) -> int"""
        return _CsoundAC.Counterpoint_BadMelody(self, Intv)


    def ASkip(self, Interval):
        """ASkip(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_ASkip(self, Interval)


    def AStep(self, Interval):
        """AStep(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_AStep(self, Interval)


    def AThird(self, Interval):
        """AThird(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_AThird(self, Interval)


    def ASeventh(self, Interval):
        """ASeventh(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_ASeventh(self, Interval)


    def AnOctave(self, Interval):
        """AnOctave(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_AnOctave(self, Interval)


    def ATenth(self, Interval):
        """ATenth(Counterpoint self, int Interval) -> int"""
        return _CsoundAC.Counterpoint_ATenth(self, Interval)

    DirectMotion = _CsoundAC.Counterpoint_DirectMotion
    ContraryMotion = _CsoundAC.Counterpoint_ContraryMotion
    ObliqueMotion = _CsoundAC.Counterpoint_ObliqueMotion
    NoMotion = _CsoundAC.Counterpoint_NoMotion

    def MotionType(self, Pitch1, Pitch2, Pitch3, Pitch4):
        """MotionType(Counterpoint self, int Pitch1, int Pitch2, int Pitch3, int Pitch4) -> int"""
        return _CsoundAC.Counterpoint_MotionType(self, Pitch1, Pitch2, Pitch3, Pitch4)


    def DirectMotionToPerfectConsonance(self, Pitch1, Pitch2, Pitch3, Pitch4):
        """DirectMotionToPerfectConsonance(Counterpoint self, int Pitch1, int Pitch2, int Pitch3, int Pitch4) -> int"""
        return _CsoundAC.Counterpoint_DirectMotionToPerfectConsonance(self, Pitch1, Pitch2, Pitch3, Pitch4)


    def ConsecutiveSkipsInSameDirection(self, Pitch1, Pitch2, Pitch3):
        """ConsecutiveSkipsInSameDirection(Counterpoint self, int Pitch1, int Pitch2, int Pitch3) -> int"""
        return _CsoundAC.Counterpoint_ConsecutiveSkipsInSameDirection(self, Pitch1, Pitch2, Pitch3)

    __swig_setmethods__["LowestSemitone"] = _CsoundAC.Counterpoint_LowestSemitone_set
    __swig_getmethods__["LowestSemitone"] = _CsoundAC.Counterpoint_LowestSemitone_get
    if _newclass:
        LowestSemitone = _swig_property(_CsoundAC.Counterpoint_LowestSemitone_get, _CsoundAC.Counterpoint_LowestSemitone_set)
    __swig_setmethods__["HighestSemitone"] = _CsoundAC.Counterpoint_HighestSemitone_set
    __swig_getmethods__["HighestSemitone"] = _CsoundAC.Counterpoint_HighestSemitone_get
    if _newclass:
        HighestSemitone = _swig_property(_CsoundAC.Counterpoint_HighestSemitone_get, _CsoundAC.Counterpoint_HighestSemitone_set)

    def OutOfRange(self, Pitch):
        """OutOfRange(Counterpoint self, int Pitch) -> int"""
        return _CsoundAC.Counterpoint_OutOfRange(self, Pitch)


    def ExtremeRange(self, Pitch):
        """ExtremeRange(Counterpoint self, int Pitch) -> int"""
        return _CsoundAC.Counterpoint_ExtremeRange(self, Pitch)

    __swig_setmethods__["BasePitch"] = _CsoundAC.Counterpoint_BasePitch_set
    __swig_getmethods__["BasePitch"] = _CsoundAC.Counterpoint_BasePitch_get
    if _newclass:
        BasePitch = _swig_property(_CsoundAC.Counterpoint_BasePitch_get, _CsoundAC.Counterpoint_BasePitch_set)
    __swig_setmethods__["Mode"] = _CsoundAC.Counterpoint_Mode_set
    __swig_getmethods__["Mode"] = _CsoundAC.Counterpoint_Mode_get
    if _newclass:
        Mode = _swig_property(_CsoundAC.Counterpoint_Mode_get, _CsoundAC.Counterpoint_Mode_set)
    __swig_setmethods__["TotalTime"] = _CsoundAC.Counterpoint_TotalTime_set
    __swig_getmethods__["TotalTime"] = _CsoundAC.Counterpoint_TotalTime_get
    if _newclass:
        TotalTime = _swig_property(_CsoundAC.Counterpoint_TotalTime_get, _CsoundAC.Counterpoint_TotalTime_set)

    def Us(self, n, v):
        """Us(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_Us(self, n, v)


    def LastNote(self, n, v):
        """LastNote(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_LastNote(self, n, v)


    def FirstNote(self, n, v):
        """FirstNote(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_FirstNote(self, n, v)


    def NextToLastNote(self, n, v):
        """NextToLastNote(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_NextToLastNote(self, n, v)


    def SetUs(self, n, p, v):
        """SetUs(Counterpoint self, int n, int p, int v)"""
        return _CsoundAC.Counterpoint_SetUs(self, n, p, v)


    def TotalRange(self, Cn, Cp, v):
        """TotalRange(Counterpoint self, int Cn, int Cp, int v) -> int"""
        return _CsoundAC.Counterpoint_TotalRange(self, Cn, Cp, v)


    def Cantus(self, n, v):
        """Cantus(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_Cantus(self, n, v)


    def VIndex(self, Time, VNum):
        """VIndex(Counterpoint self, int Time, int VNum) -> int"""
        return _CsoundAC.Counterpoint_VIndex(self, Time, VNum)


    def Other(self, Cn, v, v1):
        """Other(Counterpoint self, int Cn, int v, int v1) -> int"""
        return _CsoundAC.Counterpoint_Other(self, Cn, v, v1)


    def Bass(self, Cn, v):
        """Bass(Counterpoint self, int Cn, int v) -> int"""
        return _CsoundAC.Counterpoint_Bass(self, Cn, v)

    WholeNote = _CsoundAC.Counterpoint_WholeNote
    HalfNote = _CsoundAC.Counterpoint_HalfNote
    DottedHalfNote = _CsoundAC.Counterpoint_DottedHalfNote
    QuarterNote = _CsoundAC.Counterpoint_QuarterNote
    DottedQuarterNote = _CsoundAC.Counterpoint_DottedQuarterNote
    EighthNote = _CsoundAC.Counterpoint_EighthNote

    def Beat8(self, n):
        """Beat8(Counterpoint self, int n) -> int"""
        return _CsoundAC.Counterpoint_Beat8(self, n)


    def DownBeat(self, n, v):
        """DownBeat(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_DownBeat(self, n, v)


    def UpBeat(self, n, v):
        """UpBeat(Counterpoint self, int n, int v) -> int"""
        return _CsoundAC.Counterpoint_UpBeat(self, n, v)


    def PitchRepeats(self, Cn, Cp, v):
        """PitchRepeats(Counterpoint self, int Cn, int Cp, int v) -> int"""
        return _CsoundAC.Counterpoint_PitchRepeats(self, Cn, Cp, v)

    One = _CsoundAC.Counterpoint_One
    Two = _CsoundAC.Counterpoint_Two
    Three = _CsoundAC.Counterpoint_Three
    Four = _CsoundAC.Counterpoint_Four
    Five = _CsoundAC.Counterpoint_Five
    Six = _CsoundAC.Counterpoint_Six
    Eight = _CsoundAC.Counterpoint_Eight

    def Size(self, MelInt):
        """Size(Counterpoint self, int MelInt) -> int"""
        return _CsoundAC.Counterpoint_Size(self, MelInt)


    def TooMuchOfInterval(self, Cn, Cp, v):
        """TooMuchOfInterval(Counterpoint self, int Cn, int Cp, int v) -> int"""
        return _CsoundAC.Counterpoint_TooMuchOfInterval(self, Cn, Cp, v)


    def ADissonance(self, Interval, Cn, Cp, v, Species):
        """ADissonance(Counterpoint self, int Interval, int Cn, int Cp, int v, int Species) -> int"""
        return _CsoundAC.Counterpoint_ADissonance(self, Interval, Cn, Cp, v, Species)


    def Doubled(self, Pitch, Cn, v):
        """Doubled(Counterpoint self, int Pitch, int Cn, int v) -> int"""
        return _CsoundAC.Counterpoint_Doubled(self, Pitch, Cn, v)

    infinity = _CsoundAC.Counterpoint_infinity
    Bad = _CsoundAC.Counterpoint_Bad
    RealBad = _CsoundAC.Counterpoint_RealBad
    __swig_setmethods__["UnisonPenalty"] = _CsoundAC.Counterpoint_UnisonPenalty_set
    __swig_getmethods__["UnisonPenalty"] = _CsoundAC.Counterpoint_UnisonPenalty_get
    if _newclass:
        UnisonPenalty = _swig_property(_CsoundAC.Counterpoint_UnisonPenalty_get, _CsoundAC.Counterpoint_UnisonPenalty_set)
    __swig_setmethods__["DirectToFifthPenalty"] = _CsoundAC.Counterpoint_DirectToFifthPenalty_set
    __swig_getmethods__["DirectToFifthPenalty"] = _CsoundAC.Counterpoint_DirectToFifthPenalty_get
    if _newclass:
        DirectToFifthPenalty = _swig_property(_CsoundAC.Counterpoint_DirectToFifthPenalty_get, _CsoundAC.Counterpoint_DirectToFifthPenalty_set)
    __swig_setmethods__["DirectToOctavePenalty"] = _CsoundAC.Counterpoint_DirectToOctavePenalty_set
    __swig_getmethods__["DirectToOctavePenalty"] = _CsoundAC.Counterpoint_DirectToOctavePenalty_get
    if _newclass:
        DirectToOctavePenalty = _swig_property(_CsoundAC.Counterpoint_DirectToOctavePenalty_get, _CsoundAC.Counterpoint_DirectToOctavePenalty_set)
    __swig_setmethods__["ParallelFifthPenalty"] = _CsoundAC.Counterpoint_ParallelFifthPenalty_set
    __swig_getmethods__["ParallelFifthPenalty"] = _CsoundAC.Counterpoint_ParallelFifthPenalty_get
    if _newclass:
        ParallelFifthPenalty = _swig_property(_CsoundAC.Counterpoint_ParallelFifthPenalty_get, _CsoundAC.Counterpoint_ParallelFifthPenalty_set)
    __swig_setmethods__["ParallelUnisonPenalty"] = _CsoundAC.Counterpoint_ParallelUnisonPenalty_set
    __swig_getmethods__["ParallelUnisonPenalty"] = _CsoundAC.Counterpoint_ParallelUnisonPenalty_get
    if _newclass:
        ParallelUnisonPenalty = _swig_property(_CsoundAC.Counterpoint_ParallelUnisonPenalty_get, _CsoundAC.Counterpoint_ParallelUnisonPenalty_set)
    __swig_setmethods__["EndOnPerfectPenalty"] = _CsoundAC.Counterpoint_EndOnPerfectPenalty_set
    __swig_getmethods__["EndOnPerfectPenalty"] = _CsoundAC.Counterpoint_EndOnPerfectPenalty_get
    if _newclass:
        EndOnPerfectPenalty = _swig_property(_CsoundAC.Counterpoint_EndOnPerfectPenalty_get, _CsoundAC.Counterpoint_EndOnPerfectPenalty_set)
    __swig_setmethods__["NoLeadingTonePenalty"] = _CsoundAC.Counterpoint_NoLeadingTonePenalty_set
    __swig_getmethods__["NoLeadingTonePenalty"] = _CsoundAC.Counterpoint_NoLeadingTonePenalty_get
    if _newclass:
        NoLeadingTonePenalty = _swig_property(_CsoundAC.Counterpoint_NoLeadingTonePenalty_get, _CsoundAC.Counterpoint_NoLeadingTonePenalty_set)
    __swig_setmethods__["DissonancePenalty"] = _CsoundAC.Counterpoint_DissonancePenalty_set
    __swig_getmethods__["DissonancePenalty"] = _CsoundAC.Counterpoint_DissonancePenalty_get
    if _newclass:
        DissonancePenalty = _swig_property(_CsoundAC.Counterpoint_DissonancePenalty_get, _CsoundAC.Counterpoint_DissonancePenalty_set)
    __swig_setmethods__["OutOfRangePenalty"] = _CsoundAC.Counterpoint_OutOfRangePenalty_set
    __swig_getmethods__["OutOfRangePenalty"] = _CsoundAC.Counterpoint_OutOfRangePenalty_get
    if _newclass:
        OutOfRangePenalty = _swig_property(_CsoundAC.Counterpoint_OutOfRangePenalty_get, _CsoundAC.Counterpoint_OutOfRangePenalty_set)
    __swig_setmethods__["OutOfModePenalty"] = _CsoundAC.Counterpoint_OutOfModePenalty_set
    __swig_getmethods__["OutOfModePenalty"] = _CsoundAC.Counterpoint_OutOfModePenalty_get
    if _newclass:
        OutOfModePenalty = _swig_property(_CsoundAC.Counterpoint_OutOfModePenalty_get, _CsoundAC.Counterpoint_OutOfModePenalty_set)
    __swig_setmethods__["TwoSkipsPenalty"] = _CsoundAC.Counterpoint_TwoSkipsPenalty_set
    __swig_getmethods__["TwoSkipsPenalty"] = _CsoundAC.Counterpoint_TwoSkipsPenalty_get
    if _newclass:
        TwoSkipsPenalty = _swig_property(_CsoundAC.Counterpoint_TwoSkipsPenalty_get, _CsoundAC.Counterpoint_TwoSkipsPenalty_set)
    __swig_setmethods__["DirectMotionPenalty"] = _CsoundAC.Counterpoint_DirectMotionPenalty_set
    __swig_getmethods__["DirectMotionPenalty"] = _CsoundAC.Counterpoint_DirectMotionPenalty_get
    if _newclass:
        DirectMotionPenalty = _swig_property(_CsoundAC.Counterpoint_DirectMotionPenalty_get, _CsoundAC.Counterpoint_DirectMotionPenalty_set)
    __swig_setmethods__["PerfectConsonancePenalty"] = _CsoundAC.Counterpoint_PerfectConsonancePenalty_set
    __swig_getmethods__["PerfectConsonancePenalty"] = _CsoundAC.Counterpoint_PerfectConsonancePenalty_get
    if _newclass:
        PerfectConsonancePenalty = _swig_property(_CsoundAC.Counterpoint_PerfectConsonancePenalty_get, _CsoundAC.Counterpoint_PerfectConsonancePenalty_set)
    __swig_setmethods__["CompoundPenalty"] = _CsoundAC.Counterpoint_CompoundPenalty_set
    __swig_getmethods__["CompoundPenalty"] = _CsoundAC.Counterpoint_CompoundPenalty_get
    if _newclass:
        CompoundPenalty = _swig_property(_CsoundAC.Counterpoint_CompoundPenalty_get, _CsoundAC.Counterpoint_CompoundPenalty_set)
    __swig_setmethods__["TenthToOctavePenalty"] = _CsoundAC.Counterpoint_TenthToOctavePenalty_set
    __swig_getmethods__["TenthToOctavePenalty"] = _CsoundAC.Counterpoint_TenthToOctavePenalty_get
    if _newclass:
        TenthToOctavePenalty = _swig_property(_CsoundAC.Counterpoint_TenthToOctavePenalty_get, _CsoundAC.Counterpoint_TenthToOctavePenalty_set)
    __swig_setmethods__["SkipTo8vePenalty"] = _CsoundAC.Counterpoint_SkipTo8vePenalty_set
    __swig_getmethods__["SkipTo8vePenalty"] = _CsoundAC.Counterpoint_SkipTo8vePenalty_get
    if _newclass:
        SkipTo8vePenalty = _swig_property(_CsoundAC.Counterpoint_SkipTo8vePenalty_get, _CsoundAC.Counterpoint_SkipTo8vePenalty_set)
    __swig_setmethods__["SkipFromUnisonPenalty"] = _CsoundAC.Counterpoint_SkipFromUnisonPenalty_set
    __swig_getmethods__["SkipFromUnisonPenalty"] = _CsoundAC.Counterpoint_SkipFromUnisonPenalty_get
    if _newclass:
        SkipFromUnisonPenalty = _swig_property(_CsoundAC.Counterpoint_SkipFromUnisonPenalty_get, _CsoundAC.Counterpoint_SkipFromUnisonPenalty_set)
    __swig_setmethods__["SkipPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SkipPrecededBySameDirectionPenalty_set
    __swig_getmethods__["SkipPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SkipPrecededBySameDirectionPenalty_get
    if _newclass:
        SkipPrecededBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_SkipPrecededBySameDirectionPenalty_get, _CsoundAC.Counterpoint_SkipPrecededBySameDirectionPenalty_set)
    __swig_setmethods__["FifthPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_FifthPrecededBySameDirectionPenalty_set
    __swig_getmethods__["FifthPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_FifthPrecededBySameDirectionPenalty_get
    if _newclass:
        FifthPrecededBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_FifthPrecededBySameDirectionPenalty_get, _CsoundAC.Counterpoint_FifthPrecededBySameDirectionPenalty_set)
    __swig_setmethods__["SixthPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SixthPrecededBySameDirectionPenalty_set
    __swig_getmethods__["SixthPrecededBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SixthPrecededBySameDirectionPenalty_get
    if _newclass:
        SixthPrecededBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_SixthPrecededBySameDirectionPenalty_get, _CsoundAC.Counterpoint_SixthPrecededBySameDirectionPenalty_set)
    __swig_setmethods__["SkipFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SkipFollowedBySameDirectionPenalty_set
    __swig_getmethods__["SkipFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SkipFollowedBySameDirectionPenalty_get
    if _newclass:
        SkipFollowedBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_SkipFollowedBySameDirectionPenalty_get, _CsoundAC.Counterpoint_SkipFollowedBySameDirectionPenalty_set)
    __swig_setmethods__["FifthFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_FifthFollowedBySameDirectionPenalty_set
    __swig_getmethods__["FifthFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_FifthFollowedBySameDirectionPenalty_get
    if _newclass:
        FifthFollowedBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_FifthFollowedBySameDirectionPenalty_get, _CsoundAC.Counterpoint_FifthFollowedBySameDirectionPenalty_set)
    __swig_setmethods__["SixthFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SixthFollowedBySameDirectionPenalty_set
    __swig_getmethods__["SixthFollowedBySameDirectionPenalty"] = _CsoundAC.Counterpoint_SixthFollowedBySameDirectionPenalty_get
    if _newclass:
        SixthFollowedBySameDirectionPenalty = _swig_property(_CsoundAC.Counterpoint_SixthFollowedBySameDirectionPenalty_get, _CsoundAC.Counterpoint_SixthFollowedBySameDirectionPenalty_set)
    __swig_setmethods__["TwoSkipsNotInTriadPenalty"] = _CsoundAC.Counterpoint_TwoSkipsNotInTriadPenalty_set
    __swig_getmethods__["TwoSkipsNotInTriadPenalty"] = _CsoundAC.Counterpoint_TwoSkipsNotInTriadPenalty_get
    if _newclass:
        TwoSkipsNotInTriadPenalty = _swig_property(_CsoundAC.Counterpoint_TwoSkipsNotInTriadPenalty_get, _CsoundAC.Counterpoint_TwoSkipsNotInTriadPenalty_set)
    __swig_setmethods__["BadMelodyPenalty"] = _CsoundAC.Counterpoint_BadMelodyPenalty_set
    __swig_getmethods__["BadMelodyPenalty"] = _CsoundAC.Counterpoint_BadMelodyPenalty_get
    if _newclass:
        BadMelodyPenalty = _swig_property(_CsoundAC.Counterpoint_BadMelodyPenalty_get, _CsoundAC.Counterpoint_BadMelodyPenalty_set)
    __swig_setmethods__["ExtremeRangePenalty"] = _CsoundAC.Counterpoint_ExtremeRangePenalty_set
    __swig_getmethods__["ExtremeRangePenalty"] = _CsoundAC.Counterpoint_ExtremeRangePenalty_get
    if _newclass:
        ExtremeRangePenalty = _swig_property(_CsoundAC.Counterpoint_ExtremeRangePenalty_get, _CsoundAC.Counterpoint_ExtremeRangePenalty_set)
    __swig_setmethods__["LydianCadentialTritonePenalty"] = _CsoundAC.Counterpoint_LydianCadentialTritonePenalty_set
    __swig_getmethods__["LydianCadentialTritonePenalty"] = _CsoundAC.Counterpoint_LydianCadentialTritonePenalty_get
    if _newclass:
        LydianCadentialTritonePenalty = _swig_property(_CsoundAC.Counterpoint_LydianCadentialTritonePenalty_get, _CsoundAC.Counterpoint_LydianCadentialTritonePenalty_set)
    __swig_setmethods__["LowerNeighborPenalty"] = _CsoundAC.Counterpoint_LowerNeighborPenalty_set
    __swig_getmethods__["LowerNeighborPenalty"] = _CsoundAC.Counterpoint_LowerNeighborPenalty_get
    if _newclass:
        LowerNeighborPenalty = _swig_property(_CsoundAC.Counterpoint_LowerNeighborPenalty_get, _CsoundAC.Counterpoint_LowerNeighborPenalty_set)
    __swig_setmethods__["UpperNeighborPenalty"] = _CsoundAC.Counterpoint_UpperNeighborPenalty_set
    __swig_getmethods__["UpperNeighborPenalty"] = _CsoundAC.Counterpoint_UpperNeighborPenalty_get
    if _newclass:
        UpperNeighborPenalty = _swig_property(_CsoundAC.Counterpoint_UpperNeighborPenalty_get, _CsoundAC.Counterpoint_UpperNeighborPenalty_set)
    __swig_setmethods__["OverTwelfthPenalty"] = _CsoundAC.Counterpoint_OverTwelfthPenalty_set
    __swig_getmethods__["OverTwelfthPenalty"] = _CsoundAC.Counterpoint_OverTwelfthPenalty_get
    if _newclass:
        OverTwelfthPenalty = _swig_property(_CsoundAC.Counterpoint_OverTwelfthPenalty_get, _CsoundAC.Counterpoint_OverTwelfthPenalty_set)
    __swig_setmethods__["OverOctavePenalty"] = _CsoundAC.Counterpoint_OverOctavePenalty_set
    __swig_getmethods__["OverOctavePenalty"] = _CsoundAC.Counterpoint_OverOctavePenalty_get
    if _newclass:
        OverOctavePenalty = _swig_property(_CsoundAC.Counterpoint_OverOctavePenalty_get, _CsoundAC.Counterpoint_OverOctavePenalty_set)
    __swig_setmethods__["SixthLeapPenalty"] = _CsoundAC.Counterpoint_SixthLeapPenalty_set
    __swig_getmethods__["SixthLeapPenalty"] = _CsoundAC.Counterpoint_SixthLeapPenalty_get
    if _newclass:
        SixthLeapPenalty = _swig_property(_CsoundAC.Counterpoint_SixthLeapPenalty_get, _CsoundAC.Counterpoint_SixthLeapPenalty_set)
    __swig_setmethods__["OctaveLeapPenalty"] = _CsoundAC.Counterpoint_OctaveLeapPenalty_set
    __swig_getmethods__["OctaveLeapPenalty"] = _CsoundAC.Counterpoint_OctaveLeapPenalty_get
    if _newclass:
        OctaveLeapPenalty = _swig_property(_CsoundAC.Counterpoint_OctaveLeapPenalty_get, _CsoundAC.Counterpoint_OctaveLeapPenalty_set)
    __swig_setmethods__["BadCadencePenalty"] = _CsoundAC.Counterpoint_BadCadencePenalty_set
    __swig_getmethods__["BadCadencePenalty"] = _CsoundAC.Counterpoint_BadCadencePenalty_get
    if _newclass:
        BadCadencePenalty = _swig_property(_CsoundAC.Counterpoint_BadCadencePenalty_get, _CsoundAC.Counterpoint_BadCadencePenalty_set)
    __swig_setmethods__["DirectPerfectOnDownbeatPenalty"] = _CsoundAC.Counterpoint_DirectPerfectOnDownbeatPenalty_set
    __swig_getmethods__["DirectPerfectOnDownbeatPenalty"] = _CsoundAC.Counterpoint_DirectPerfectOnDownbeatPenalty_get
    if _newclass:
        DirectPerfectOnDownbeatPenalty = _swig_property(_CsoundAC.Counterpoint_DirectPerfectOnDownbeatPenalty_get, _CsoundAC.Counterpoint_DirectPerfectOnDownbeatPenalty_set)
    __swig_setmethods__["RepetitionOnUpbeatPenalty"] = _CsoundAC.Counterpoint_RepetitionOnUpbeatPenalty_set
    __swig_getmethods__["RepetitionOnUpbeatPenalty"] = _CsoundAC.Counterpoint_RepetitionOnUpbeatPenalty_get
    if _newclass:
        RepetitionOnUpbeatPenalty = _swig_property(_CsoundAC.Counterpoint_RepetitionOnUpbeatPenalty_get, _CsoundAC.Counterpoint_RepetitionOnUpbeatPenalty_set)
    __swig_setmethods__["DissonanceNotFillingThirdPenalty"] = _CsoundAC.Counterpoint_DissonanceNotFillingThirdPenalty_set
    __swig_getmethods__["DissonanceNotFillingThirdPenalty"] = _CsoundAC.Counterpoint_DissonanceNotFillingThirdPenalty_get
    if _newclass:
        DissonanceNotFillingThirdPenalty = _swig_property(_CsoundAC.Counterpoint_DissonanceNotFillingThirdPenalty_get, _CsoundAC.Counterpoint_DissonanceNotFillingThirdPenalty_set)
    __swig_setmethods__["UnisonDownbeatPenalty"] = _CsoundAC.Counterpoint_UnisonDownbeatPenalty_set
    __swig_getmethods__["UnisonDownbeatPenalty"] = _CsoundAC.Counterpoint_UnisonDownbeatPenalty_get
    if _newclass:
        UnisonDownbeatPenalty = _swig_property(_CsoundAC.Counterpoint_UnisonDownbeatPenalty_get, _CsoundAC.Counterpoint_UnisonDownbeatPenalty_set)
    __swig_setmethods__["TwoRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_TwoRepeatedNotesPenalty_set
    __swig_getmethods__["TwoRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_TwoRepeatedNotesPenalty_get
    if _newclass:
        TwoRepeatedNotesPenalty = _swig_property(_CsoundAC.Counterpoint_TwoRepeatedNotesPenalty_get, _CsoundAC.Counterpoint_TwoRepeatedNotesPenalty_set)
    __swig_setmethods__["ThreeRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_ThreeRepeatedNotesPenalty_set
    __swig_getmethods__["ThreeRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_ThreeRepeatedNotesPenalty_get
    if _newclass:
        ThreeRepeatedNotesPenalty = _swig_property(_CsoundAC.Counterpoint_ThreeRepeatedNotesPenalty_get, _CsoundAC.Counterpoint_ThreeRepeatedNotesPenalty_set)
    __swig_setmethods__["FourRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_FourRepeatedNotesPenalty_set
    __swig_getmethods__["FourRepeatedNotesPenalty"] = _CsoundAC.Counterpoint_FourRepeatedNotesPenalty_get
    if _newclass:
        FourRepeatedNotesPenalty = _swig_property(_CsoundAC.Counterpoint_FourRepeatedNotesPenalty_get, _CsoundAC.Counterpoint_FourRepeatedNotesPenalty_set)
    __swig_setmethods__["LeapAtCadencePenalty"] = _CsoundAC.Counterpoint_LeapAtCadencePenalty_set
    __swig_getmethods__["LeapAtCadencePenalty"] = _CsoundAC.Counterpoint_LeapAtCadencePenalty_get
    if _newclass:
        LeapAtCadencePenalty = _swig_property(_CsoundAC.Counterpoint_LeapAtCadencePenalty_get, _CsoundAC.Counterpoint_LeapAtCadencePenalty_set)
    __swig_setmethods__["NotaCambiataPenalty"] = _CsoundAC.Counterpoint_NotaCambiataPenalty_set
    __swig_getmethods__["NotaCambiataPenalty"] = _CsoundAC.Counterpoint_NotaCambiataPenalty_get
    if _newclass:
        NotaCambiataPenalty = _swig_property(_CsoundAC.Counterpoint_NotaCambiataPenalty_get, _CsoundAC.Counterpoint_NotaCambiataPenalty_set)
    __swig_setmethods__["NotBestCadencePenalty"] = _CsoundAC.Counterpoint_NotBestCadencePenalty_set
    __swig_getmethods__["NotBestCadencePenalty"] = _CsoundAC.Counterpoint_NotBestCadencePenalty_get
    if _newclass:
        NotBestCadencePenalty = _swig_property(_CsoundAC.Counterpoint_NotBestCadencePenalty_get, _CsoundAC.Counterpoint_NotBestCadencePenalty_set)
    __swig_setmethods__["UnisonOnBeat4Penalty"] = _CsoundAC.Counterpoint_UnisonOnBeat4Penalty_set
    __swig_getmethods__["UnisonOnBeat4Penalty"] = _CsoundAC.Counterpoint_UnisonOnBeat4Penalty_get
    if _newclass:
        UnisonOnBeat4Penalty = _swig_property(_CsoundAC.Counterpoint_UnisonOnBeat4Penalty_get, _CsoundAC.Counterpoint_UnisonOnBeat4Penalty_set)
    __swig_setmethods__["NotaLigaturePenalty"] = _CsoundAC.Counterpoint_NotaLigaturePenalty_set
    __swig_getmethods__["NotaLigaturePenalty"] = _CsoundAC.Counterpoint_NotaLigaturePenalty_get
    if _newclass:
        NotaLigaturePenalty = _swig_property(_CsoundAC.Counterpoint_NotaLigaturePenalty_get, _CsoundAC.Counterpoint_NotaLigaturePenalty_set)
    __swig_setmethods__["LesserLigaturePenalty"] = _CsoundAC.Counterpoint_LesserLigaturePenalty_set
    __swig_getmethods__["LesserLigaturePenalty"] = _CsoundAC.Counterpoint_LesserLigaturePenalty_get
    if _newclass:
        LesserLigaturePenalty = _swig_property(_CsoundAC.Counterpoint_LesserLigaturePenalty_get, _CsoundAC.Counterpoint_LesserLigaturePenalty_set)
    __swig_setmethods__["UnresolvedLigaturePenalty"] = _CsoundAC.Counterpoint_UnresolvedLigaturePenalty_set
    __swig_getmethods__["UnresolvedLigaturePenalty"] = _CsoundAC.Counterpoint_UnresolvedLigaturePenalty_get
    if _newclass:
        UnresolvedLigaturePenalty = _swig_property(_CsoundAC.Counterpoint_UnresolvedLigaturePenalty_get, _CsoundAC.Counterpoint_UnresolvedLigaturePenalty_set)
    __swig_setmethods__["NoTimeForaLigaturePenalty"] = _CsoundAC.Counterpoint_NoTimeForaLigaturePenalty_set
    __swig_getmethods__["NoTimeForaLigaturePenalty"] = _CsoundAC.Counterpoint_NoTimeForaLigaturePenalty_get
    if _newclass:
        NoTimeForaLigaturePenalty = _swig_property(_CsoundAC.Counterpoint_NoTimeForaLigaturePenalty_get, _CsoundAC.Counterpoint_NoTimeForaLigaturePenalty_set)
    __swig_setmethods__["EighthJumpPenalty"] = _CsoundAC.Counterpoint_EighthJumpPenalty_set
    __swig_getmethods__["EighthJumpPenalty"] = _CsoundAC.Counterpoint_EighthJumpPenalty_get
    if _newclass:
        EighthJumpPenalty = _swig_property(_CsoundAC.Counterpoint_EighthJumpPenalty_get, _CsoundAC.Counterpoint_EighthJumpPenalty_set)
    __swig_setmethods__["HalfUntiedPenalty"] = _CsoundAC.Counterpoint_HalfUntiedPenalty_set
    __swig_getmethods__["HalfUntiedPenalty"] = _CsoundAC.Counterpoint_HalfUntiedPenalty_get
    if _newclass:
        HalfUntiedPenalty = _swig_property(_CsoundAC.Counterpoint_HalfUntiedPenalty_get, _CsoundAC.Counterpoint_HalfUntiedPenalty_set)
    __swig_setmethods__["UnisonUpbeatPenalty"] = _CsoundAC.Counterpoint_UnisonUpbeatPenalty_set
    __swig_getmethods__["UnisonUpbeatPenalty"] = _CsoundAC.Counterpoint_UnisonUpbeatPenalty_get
    if _newclass:
        UnisonUpbeatPenalty = _swig_property(_CsoundAC.Counterpoint_UnisonUpbeatPenalty_get, _CsoundAC.Counterpoint_UnisonUpbeatPenalty_set)
    __swig_setmethods__["MelodicBoredomPenalty"] = _CsoundAC.Counterpoint_MelodicBoredomPenalty_set
    __swig_getmethods__["MelodicBoredomPenalty"] = _CsoundAC.Counterpoint_MelodicBoredomPenalty_get
    if _newclass:
        MelodicBoredomPenalty = _swig_property(_CsoundAC.Counterpoint_MelodicBoredomPenalty_get, _CsoundAC.Counterpoint_MelodicBoredomPenalty_set)
    __swig_setmethods__["SkipToDownBeatPenalty"] = _CsoundAC.Counterpoint_SkipToDownBeatPenalty_set
    __swig_getmethods__["SkipToDownBeatPenalty"] = _CsoundAC.Counterpoint_SkipToDownBeatPenalty_get
    if _newclass:
        SkipToDownBeatPenalty = _swig_property(_CsoundAC.Counterpoint_SkipToDownBeatPenalty_get, _CsoundAC.Counterpoint_SkipToDownBeatPenalty_set)
    __swig_setmethods__["ThreeSkipsPenalty"] = _CsoundAC.Counterpoint_ThreeSkipsPenalty_set
    __swig_getmethods__["ThreeSkipsPenalty"] = _CsoundAC.Counterpoint_ThreeSkipsPenalty_get
    if _newclass:
        ThreeSkipsPenalty = _swig_property(_CsoundAC.Counterpoint_ThreeSkipsPenalty_get, _CsoundAC.Counterpoint_ThreeSkipsPenalty_set)
    __swig_setmethods__["DownBeatUnisonPenalty"] = _CsoundAC.Counterpoint_DownBeatUnisonPenalty_set
    __swig_getmethods__["DownBeatUnisonPenalty"] = _CsoundAC.Counterpoint_DownBeatUnisonPenalty_get
    if _newclass:
        DownBeatUnisonPenalty = _swig_property(_CsoundAC.Counterpoint_DownBeatUnisonPenalty_get, _CsoundAC.Counterpoint_DownBeatUnisonPenalty_set)
    __swig_setmethods__["VerticalTritonePenalty"] = _CsoundAC.Counterpoint_VerticalTritonePenalty_set
    __swig_getmethods__["VerticalTritonePenalty"] = _CsoundAC.Counterpoint_VerticalTritonePenalty_get
    if _newclass:
        VerticalTritonePenalty = _swig_property(_CsoundAC.Counterpoint_VerticalTritonePenalty_get, _CsoundAC.Counterpoint_VerticalTritonePenalty_set)
    __swig_setmethods__["MelodicTritonePenalty"] = _CsoundAC.Counterpoint_MelodicTritonePenalty_set
    __swig_getmethods__["MelodicTritonePenalty"] = _CsoundAC.Counterpoint_MelodicTritonePenalty_get
    if _newclass:
        MelodicTritonePenalty = _swig_property(_CsoundAC.Counterpoint_MelodicTritonePenalty_get, _CsoundAC.Counterpoint_MelodicTritonePenalty_set)
    __swig_setmethods__["AscendingSixthPenalty"] = _CsoundAC.Counterpoint_AscendingSixthPenalty_set
    __swig_getmethods__["AscendingSixthPenalty"] = _CsoundAC.Counterpoint_AscendingSixthPenalty_get
    if _newclass:
        AscendingSixthPenalty = _swig_property(_CsoundAC.Counterpoint_AscendingSixthPenalty_get, _CsoundAC.Counterpoint_AscendingSixthPenalty_set)
    __swig_setmethods__["RepeatedPitchPenalty"] = _CsoundAC.Counterpoint_RepeatedPitchPenalty_set
    __swig_getmethods__["RepeatedPitchPenalty"] = _CsoundAC.Counterpoint_RepeatedPitchPenalty_get
    if _newclass:
        RepeatedPitchPenalty = _swig_property(_CsoundAC.Counterpoint_RepeatedPitchPenalty_get, _CsoundAC.Counterpoint_RepeatedPitchPenalty_set)
    __swig_setmethods__["NotContraryToOthersPenalty"] = _CsoundAC.Counterpoint_NotContraryToOthersPenalty_set
    __swig_getmethods__["NotContraryToOthersPenalty"] = _CsoundAC.Counterpoint_NotContraryToOthersPenalty_get
    if _newclass:
        NotContraryToOthersPenalty = _swig_property(_CsoundAC.Counterpoint_NotContraryToOthersPenalty_get, _CsoundAC.Counterpoint_NotContraryToOthersPenalty_set)
    __swig_setmethods__["NotTriadPenalty"] = _CsoundAC.Counterpoint_NotTriadPenalty_set
    __swig_getmethods__["NotTriadPenalty"] = _CsoundAC.Counterpoint_NotTriadPenalty_get
    if _newclass:
        NotTriadPenalty = _swig_property(_CsoundAC.Counterpoint_NotTriadPenalty_get, _CsoundAC.Counterpoint_NotTriadPenalty_set)
    __swig_setmethods__["InnerVoicesInDirectToPerfectPenalty"] = _CsoundAC.Counterpoint_InnerVoicesInDirectToPerfectPenalty_set
    __swig_getmethods__["InnerVoicesInDirectToPerfectPenalty"] = _CsoundAC.Counterpoint_InnerVoicesInDirectToPerfectPenalty_get
    if _newclass:
        InnerVoicesInDirectToPerfectPenalty = _swig_property(_CsoundAC.Counterpoint_InnerVoicesInDirectToPerfectPenalty_get, _CsoundAC.Counterpoint_InnerVoicesInDirectToPerfectPenalty_set)
    __swig_setmethods__["InnerVoicesInDirectToTritonePenalty"] = _CsoundAC.Counterpoint_InnerVoicesInDirectToTritonePenalty_set
    __swig_getmethods__["InnerVoicesInDirectToTritonePenalty"] = _CsoundAC.Counterpoint_InnerVoicesInDirectToTritonePenalty_get
    if _newclass:
        InnerVoicesInDirectToTritonePenalty = _swig_property(_CsoundAC.Counterpoint_InnerVoicesInDirectToTritonePenalty_get, _CsoundAC.Counterpoint_InnerVoicesInDirectToTritonePenalty_set)
    __swig_setmethods__["SixFiveChordPenalty"] = _CsoundAC.Counterpoint_SixFiveChordPenalty_set
    __swig_getmethods__["SixFiveChordPenalty"] = _CsoundAC.Counterpoint_SixFiveChordPenalty_get
    if _newclass:
        SixFiveChordPenalty = _swig_property(_CsoundAC.Counterpoint_SixFiveChordPenalty_get, _CsoundAC.Counterpoint_SixFiveChordPenalty_set)
    __swig_setmethods__["UnpreparedSixFivePenalty"] = _CsoundAC.Counterpoint_UnpreparedSixFivePenalty_set
    __swig_getmethods__["UnpreparedSixFivePenalty"] = _CsoundAC.Counterpoint_UnpreparedSixFivePenalty_get
    if _newclass:
        UnpreparedSixFivePenalty = _swig_property(_CsoundAC.Counterpoint_UnpreparedSixFivePenalty_get, _CsoundAC.Counterpoint_UnpreparedSixFivePenalty_set)
    __swig_setmethods__["UnresolvedSixFivePenalty"] = _CsoundAC.Counterpoint_UnresolvedSixFivePenalty_set
    __swig_getmethods__["UnresolvedSixFivePenalty"] = _CsoundAC.Counterpoint_UnresolvedSixFivePenalty_get
    if _newclass:
        UnresolvedSixFivePenalty = _swig_property(_CsoundAC.Counterpoint_UnresolvedSixFivePenalty_get, _CsoundAC.Counterpoint_UnresolvedSixFivePenalty_set)
    __swig_setmethods__["AugmentedIntervalPenalty"] = _CsoundAC.Counterpoint_AugmentedIntervalPenalty_set
    __swig_getmethods__["AugmentedIntervalPenalty"] = _CsoundAC.Counterpoint_AugmentedIntervalPenalty_get
    if _newclass:
        AugmentedIntervalPenalty = _swig_property(_CsoundAC.Counterpoint_AugmentedIntervalPenalty_get, _CsoundAC.Counterpoint_AugmentedIntervalPenalty_set)
    __swig_setmethods__["ThirdDoubledPenalty"] = _CsoundAC.Counterpoint_ThirdDoubledPenalty_set
    __swig_getmethods__["ThirdDoubledPenalty"] = _CsoundAC.Counterpoint_ThirdDoubledPenalty_get
    if _newclass:
        ThirdDoubledPenalty = _swig_property(_CsoundAC.Counterpoint_ThirdDoubledPenalty_get, _CsoundAC.Counterpoint_ThirdDoubledPenalty_set)
    __swig_setmethods__["DoubledLeadingTonePenalty"] = _CsoundAC.Counterpoint_DoubledLeadingTonePenalty_set
    __swig_getmethods__["DoubledLeadingTonePenalty"] = _CsoundAC.Counterpoint_DoubledLeadingTonePenalty_get
    if _newclass:
        DoubledLeadingTonePenalty = _swig_property(_CsoundAC.Counterpoint_DoubledLeadingTonePenalty_get, _CsoundAC.Counterpoint_DoubledLeadingTonePenalty_set)
    __swig_setmethods__["DoubledSixthPenalty"] = _CsoundAC.Counterpoint_DoubledSixthPenalty_set
    __swig_getmethods__["DoubledSixthPenalty"] = _CsoundAC.Counterpoint_DoubledSixthPenalty_get
    if _newclass:
        DoubledSixthPenalty = _swig_property(_CsoundAC.Counterpoint_DoubledSixthPenalty_get, _CsoundAC.Counterpoint_DoubledSixthPenalty_set)
    __swig_setmethods__["DoubledFifthPenalty"] = _CsoundAC.Counterpoint_DoubledFifthPenalty_set
    __swig_getmethods__["DoubledFifthPenalty"] = _CsoundAC.Counterpoint_DoubledFifthPenalty_get
    if _newclass:
        DoubledFifthPenalty = _swig_property(_CsoundAC.Counterpoint_DoubledFifthPenalty_get, _CsoundAC.Counterpoint_DoubledFifthPenalty_set)
    __swig_setmethods__["TripledBassPenalty"] = _CsoundAC.Counterpoint_TripledBassPenalty_set
    __swig_getmethods__["TripledBassPenalty"] = _CsoundAC.Counterpoint_TripledBassPenalty_get
    if _newclass:
        TripledBassPenalty = _swig_property(_CsoundAC.Counterpoint_TripledBassPenalty_get, _CsoundAC.Counterpoint_TripledBassPenalty_set)
    __swig_setmethods__["UpperVoicesTooFarApartPenalty"] = _CsoundAC.Counterpoint_UpperVoicesTooFarApartPenalty_set
    __swig_getmethods__["UpperVoicesTooFarApartPenalty"] = _CsoundAC.Counterpoint_UpperVoicesTooFarApartPenalty_get
    if _newclass:
        UpperVoicesTooFarApartPenalty = _swig_property(_CsoundAC.Counterpoint_UpperVoicesTooFarApartPenalty_get, _CsoundAC.Counterpoint_UpperVoicesTooFarApartPenalty_set)
    __swig_setmethods__["UnresolvedLeadingTonePenalty"] = _CsoundAC.Counterpoint_UnresolvedLeadingTonePenalty_set
    __swig_getmethods__["UnresolvedLeadingTonePenalty"] = _CsoundAC.Counterpoint_UnresolvedLeadingTonePenalty_get
    if _newclass:
        UnresolvedLeadingTonePenalty = _swig_property(_CsoundAC.Counterpoint_UnresolvedLeadingTonePenalty_get, _CsoundAC.Counterpoint_UnresolvedLeadingTonePenalty_set)
    __swig_setmethods__["AllVoicesSkipPenalty"] = _CsoundAC.Counterpoint_AllVoicesSkipPenalty_set
    __swig_getmethods__["AllVoicesSkipPenalty"] = _CsoundAC.Counterpoint_AllVoicesSkipPenalty_get
    if _newclass:
        AllVoicesSkipPenalty = _swig_property(_CsoundAC.Counterpoint_AllVoicesSkipPenalty_get, _CsoundAC.Counterpoint_AllVoicesSkipPenalty_set)
    __swig_setmethods__["DirectToTritonePenalty"] = _CsoundAC.Counterpoint_DirectToTritonePenalty_set
    __swig_getmethods__["DirectToTritonePenalty"] = _CsoundAC.Counterpoint_DirectToTritonePenalty_get
    if _newclass:
        DirectToTritonePenalty = _swig_property(_CsoundAC.Counterpoint_DirectToTritonePenalty_get, _CsoundAC.Counterpoint_DirectToTritonePenalty_set)
    __swig_setmethods__["CrossBelowBassPenalty"] = _CsoundAC.Counterpoint_CrossBelowBassPenalty_set
    __swig_getmethods__["CrossBelowBassPenalty"] = _CsoundAC.Counterpoint_CrossBelowBassPenalty_get
    if _newclass:
        CrossBelowBassPenalty = _swig_property(_CsoundAC.Counterpoint_CrossBelowBassPenalty_get, _CsoundAC.Counterpoint_CrossBelowBassPenalty_set)
    __swig_setmethods__["CrossAboveCantusPenalty"] = _CsoundAC.Counterpoint_CrossAboveCantusPenalty_set
    __swig_getmethods__["CrossAboveCantusPenalty"] = _CsoundAC.Counterpoint_CrossAboveCantusPenalty_get
    if _newclass:
        CrossAboveCantusPenalty = _swig_property(_CsoundAC.Counterpoint_CrossAboveCantusPenalty_get, _CsoundAC.Counterpoint_CrossAboveCantusPenalty_set)
    __swig_setmethods__["NoMotionAgainstOctavePenalty"] = _CsoundAC.Counterpoint_NoMotionAgainstOctavePenalty_set
    __swig_getmethods__["NoMotionAgainstOctavePenalty"] = _CsoundAC.Counterpoint_NoMotionAgainstOctavePenalty_get
    if _newclass:
        NoMotionAgainstOctavePenalty = _swig_property(_CsoundAC.Counterpoint_NoMotionAgainstOctavePenalty_get, _CsoundAC.Counterpoint_NoMotionAgainstOctavePenalty_set)

    def SpecialSpeciesCheck(self, Cn, Cp, v, Other0, Other1, Other2, NumParts, Species, MelInt, Interval, ActInt, LastIntClass, Pitch, LastMelInt, CurLim):
        """SpecialSpeciesCheck(Counterpoint self, int Cn, int Cp, int v, int Other0, int Other1, int Other2, int NumParts, int Species, int MelInt, int Interval, int ActInt, int LastIntClass, int Pitch, int LastMelInt, int CurLim) -> int"""
        return _CsoundAC.Counterpoint_SpecialSpeciesCheck(self, Cn, Cp, v, Other0, Other1, Other2, NumParts, Species, MelInt, Interval, ActInt, LastIntClass, Pitch, LastMelInt, CurLim)

    INTERVALS_WITH_BASS_SIZE = _CsoundAC.Counterpoint_INTERVALS_WITH_BASS_SIZE
    __swig_setmethods__["IntervalsWithBass"] = _CsoundAC.Counterpoint_IntervalsWithBass_set
    __swig_getmethods__["IntervalsWithBass"] = _CsoundAC.Counterpoint_IntervalsWithBass_get
    if _newclass:
        IntervalsWithBass = _swig_property(_CsoundAC.Counterpoint_IntervalsWithBass_get, _CsoundAC.Counterpoint_IntervalsWithBass_set)

    def AddInterval(self, n):
        """AddInterval(Counterpoint self, int n)"""
        return _CsoundAC.Counterpoint_AddInterval(self, n)


    def OtherVoiceCheck(self, Cn, Cp, v, NumParts, Species, CurLim):
        """OtherVoiceCheck(Counterpoint self, int Cn, int Cp, int v, int NumParts, int Species, int CurLim) -> int"""
        return _CsoundAC.Counterpoint_OtherVoiceCheck(self, Cn, Cp, v, NumParts, Species, CurLim)


    def Check(self, Cn, Cp, v, NumParts, Species, CurLim):
        """Check(Counterpoint self, int Cn, int Cp, int v, int NumParts, int Species, int CurLim) -> int"""
        return _CsoundAC.Counterpoint_Check(self, Cn, Cp, v, NumParts, Species, CurLim)

    __swig_setmethods__["BestFitPenalty"] = _CsoundAC.Counterpoint_BestFitPenalty_set
    __swig_getmethods__["BestFitPenalty"] = _CsoundAC.Counterpoint_BestFitPenalty_get
    if _newclass:
        BestFitPenalty = _swig_property(_CsoundAC.Counterpoint_BestFitPenalty_get, _CsoundAC.Counterpoint_BestFitPenalty_set)
    __swig_setmethods__["MaxPenalty"] = _CsoundAC.Counterpoint_MaxPenalty_set
    __swig_getmethods__["MaxPenalty"] = _CsoundAC.Counterpoint_MaxPenalty_get
    if _newclass:
        MaxPenalty = _swig_property(_CsoundAC.Counterpoint_MaxPenalty_get, _CsoundAC.Counterpoint_MaxPenalty_set)
    __swig_setmethods__["Branches"] = _CsoundAC.Counterpoint_Branches_set
    __swig_getmethods__["Branches"] = _CsoundAC.Counterpoint_Branches_get
    if _newclass:
        Branches = _swig_property(_CsoundAC.Counterpoint_Branches_get, _CsoundAC.Counterpoint_Branches_set)
    __swig_setmethods__["AllDone"] = _CsoundAC.Counterpoint_AllDone_set
    __swig_getmethods__["AllDone"] = _CsoundAC.Counterpoint_AllDone_get
    if _newclass:
        AllDone = _swig_property(_CsoundAC.Counterpoint_AllDone_get, _CsoundAC.Counterpoint_AllDone_set)
    __swig_setmethods__["PenaltyRatio"] = _CsoundAC.Counterpoint_PenaltyRatio_set
    __swig_getmethods__["PenaltyRatio"] = _CsoundAC.Counterpoint_PenaltyRatio_get
    if _newclass:
        PenaltyRatio = _swig_property(_CsoundAC.Counterpoint_PenaltyRatio_get, _CsoundAC.Counterpoint_PenaltyRatio_set)
    NumFields = _CsoundAC.Counterpoint_NumFields
    Field = _CsoundAC.Counterpoint_Field
    EndF = _CsoundAC.Counterpoint_EndF

    def SaveIndx(self, indx, Sp):
        """SaveIndx(Counterpoint self, int indx, int * Sp) -> int"""
        return _CsoundAC.Counterpoint_SaveIndx(self, indx, Sp)


    def SaveResults(self, CurrentPenalty, Penalty, v1, Species):
        """SaveResults(Counterpoint self, int CurrentPenalty, int Penalty, int v1, int Species)"""
        return _CsoundAC.Counterpoint_SaveResults(self, CurrentPenalty, Penalty, v1, Species)


    def Look(self, CurPen, CurVoice, NumParts, Species, Lim, Pens, Is, CurNotes):
        """Look(Counterpoint self, int CurPen, int CurVoice, int NumParts, int Species, int Lim, int * Pens, int * Is, int * CurNotes) -> int"""
        return _CsoundAC.Counterpoint_Look(self, CurPen, CurVoice, NumParts, Species, Lim, Pens, Is, CurNotes)


    def BestFitFirst(self, CurTime, CurrentPenalty, NumParts, Species, BrLim):
        """BestFitFirst(Counterpoint self, int CurTime, int CurrentPenalty, int NumParts, int Species, int BrLim)"""
        return _CsoundAC.Counterpoint_BestFitFirst(self, CurTime, CurrentPenalty, NumParts, Species, BrLim)


    def FillRhyPat(self):
        """FillRhyPat(Counterpoint self)"""
        return _CsoundAC.Counterpoint_FillRhyPat(self)


    def RANDOM(self, amp):
        """RANDOM(Counterpoint self, float amp) -> float"""
        return _CsoundAC.Counterpoint_RANDOM(self, amp)


    def UsedRhy(self, n):
        """UsedRhy(Counterpoint self, int n)"""
        return _CsoundAC.Counterpoint_UsedRhy(self, n)


    def CurRhy(self, n):
        """CurRhy(Counterpoint self, int n) -> int"""
        return _CsoundAC.Counterpoint_CurRhy(self, n)


    def CleanRhy(self):
        """CleanRhy(Counterpoint self)"""
        return _CsoundAC.Counterpoint_CleanRhy(self)


    def GoodRhy(self):
        """GoodRhy(Counterpoint self) -> int"""
        return _CsoundAC.Counterpoint_GoodRhy(self)


    def counterpoint(self, OurMode, StartPitches, CurV, CantusFirmusLength, Species, cantus):
        """counterpoint(Counterpoint self, int OurMode, int * StartPitches, int CurV, int CantusFirmusLength, int Species, int * cantus)"""
        return _CsoundAC.Counterpoint_counterpoint(self, OurMode, StartPitches, CurV, CantusFirmusLength, Species, cantus)


    def AnySpecies(self, OurMode, StartPitches, CurV, CantusFirmusLength, Species):
        """AnySpecies(Counterpoint self, int OurMode, int * StartPitches, int CurV, int CantusFirmusLength, int Species)"""
        return _CsoundAC.Counterpoint_AnySpecies(self, OurMode, StartPitches, CurV, CantusFirmusLength, Species)


    def fillCantus(self, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14):
        """fillCantus(Counterpoint self, int c0, int c1, int c2, int c3, int c4, int c5, int c6, int c7, int c8, int c9, int c10, int c11, int c12, int c13, int c14)"""
        return _CsoundAC.Counterpoint_fillCantus(self, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14)


    def toCsoundScore(self, filename, secondsPerPulse):
        """toCsoundScore(Counterpoint self, std::string filename, double secondsPerPulse)"""
        return _CsoundAC.Counterpoint_toCsoundScore(self, filename, secondsPerPulse)


    def winners(self, v1, data, best, best1, best2, durs):
        """winners(Counterpoint self, int v1, int * data, int * best, int * best1, int * best2, int * durs)"""
        return _CsoundAC.Counterpoint_winners(self, v1, data, best, best1, best2, durs)

Counterpoint_swigregister = _CsoundAC.Counterpoint_swigregister
Counterpoint_swigregister(Counterpoint)

class IntVector(_object):
    """Proxy of C++ std::vector<(int)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(IntVector self) -> SwigPyIterator"""
        return _CsoundAC.IntVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(IntVector self) -> bool"""
        return _CsoundAC.IntVector___nonzero__(self)


    def __bool__(self):
        """__bool__(IntVector self) -> bool"""
        return _CsoundAC.IntVector___bool__(self)


    def __len__(self):
        """__len__(IntVector self) -> std::vector< int >::size_type"""
        return _CsoundAC.IntVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"""
        return _CsoundAC.IntVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)
        """
        return _CsoundAC.IntVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _CsoundAC.IntVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(IntVector self, std::vector< int >::difference_type i)
        __delitem__(IntVector self, PySliceObject * slice)
        """
        return _CsoundAC.IntVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(IntVector self, PySliceObject * slice) -> IntVector
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _CsoundAC.IntVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(IntVector self, PySliceObject * slice, IntVector v)
        __setitem__(IntVector self, PySliceObject * slice)
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _CsoundAC.IntVector___setitem__(self, *args)


    def pop(self):
        """pop(IntVector self) -> std::vector< int >::value_type"""
        return _CsoundAC.IntVector_pop(self)


    def append(self, x):
        """append(IntVector self, std::vector< int >::value_type const & x)"""
        return _CsoundAC.IntVector_append(self, x)


    def empty(self):
        """empty(IntVector self) -> bool"""
        return _CsoundAC.IntVector_empty(self)


    def size(self):
        """size(IntVector self) -> std::vector< int >::size_type"""
        return _CsoundAC.IntVector_size(self)


    def swap(self, v):
        """swap(IntVector self, IntVector v)"""
        return _CsoundAC.IntVector_swap(self, v)


    def begin(self):
        """begin(IntVector self) -> std::vector< int >::iterator"""
        return _CsoundAC.IntVector_begin(self)


    def end(self):
        """end(IntVector self) -> std::vector< int >::iterator"""
        return _CsoundAC.IntVector_end(self)


    def rbegin(self):
        """rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _CsoundAC.IntVector_rbegin(self)


    def rend(self):
        """rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _CsoundAC.IntVector_rend(self)


    def clear(self):
        """clear(IntVector self)"""
        return _CsoundAC.IntVector_clear(self)


    def get_allocator(self):
        """get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return _CsoundAC.IntVector_get_allocator(self)


    def pop_back(self):
        """pop_back(IntVector self)"""
        return _CsoundAC.IntVector_pop_back(self)


    def erase(self, *args):
        """
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _CsoundAC.IntVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> IntVector
        __init__(std::vector<(int)> self, IntVector arg2) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        this = _CsoundAC.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _CsoundAC.IntVector_push_back(self, x)


    def front(self):
        """front(IntVector self) -> std::vector< int >::value_type const &"""
        return _CsoundAC.IntVector_front(self)


    def back(self):
        """back(IntVector self) -> std::vector< int >::value_type const &"""
        return _CsoundAC.IntVector_back(self)


    def assign(self, n, x):
        """assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _CsoundAC.IntVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(IntVector self, std::vector< int >::size_type new_size)
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _CsoundAC.IntVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _CsoundAC.IntVector_insert(self, *args)


    def reserve(self, n):
        """reserve(IntVector self, std::vector< int >::size_type n)"""
        return _CsoundAC.IntVector_reserve(self, n)


    def capacity(self):
        """capacity(IntVector self) -> std::vector< int >::size_type"""
        return _CsoundAC.IntVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _CsoundAC.IntVector_swigregister
IntVector_swigregister(IntVector)

class CounterpointNode(Node, Counterpoint):
    """Proxy of C++ csound::CounterpointNode class."""

    __swig_setmethods__ = {}
    for _s in [Node, Counterpoint]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CounterpointNode, name, value)
    __swig_getmethods__ = {}
    for _s in [Node, Counterpoint]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CounterpointNode, name)
    __repr__ = _swig_repr
    GenerateCounterpoint = _CsoundAC.CounterpointNode_GenerateCounterpoint
    CorrectCounterpoint = _CsoundAC.CounterpointNode_CorrectCounterpoint
    __swig_setmethods__["generationMode"] = _CsoundAC.CounterpointNode_generationMode_set
    __swig_getmethods__["generationMode"] = _CsoundAC.CounterpointNode_generationMode_get
    if _newclass:
        generationMode = _swig_property(_CsoundAC.CounterpointNode_generationMode_get, _CsoundAC.CounterpointNode_generationMode_set)
    __swig_setmethods__["musicMode"] = _CsoundAC.CounterpointNode_musicMode_set
    __swig_getmethods__["musicMode"] = _CsoundAC.CounterpointNode_musicMode_get
    if _newclass:
        musicMode = _swig_property(_CsoundAC.CounterpointNode_musicMode_get, _CsoundAC.CounterpointNode_musicMode_set)
    __swig_setmethods__["species"] = _CsoundAC.CounterpointNode_species_set
    __swig_getmethods__["species"] = _CsoundAC.CounterpointNode_species_get
    if _newclass:
        species = _swig_property(_CsoundAC.CounterpointNode_species_get, _CsoundAC.CounterpointNode_species_set)
    __swig_setmethods__["voices"] = _CsoundAC.CounterpointNode_voices_set
    __swig_getmethods__["voices"] = _CsoundAC.CounterpointNode_voices_get
    if _newclass:
        voices = _swig_property(_CsoundAC.CounterpointNode_voices_get, _CsoundAC.CounterpointNode_voices_set)
    __swig_setmethods__["secondsPerPulse"] = _CsoundAC.CounterpointNode_secondsPerPulse_set
    __swig_getmethods__["secondsPerPulse"] = _CsoundAC.CounterpointNode_secondsPerPulse_get
    if _newclass:
        secondsPerPulse = _swig_property(_CsoundAC.CounterpointNode_secondsPerPulse_get, _CsoundAC.CounterpointNode_secondsPerPulse_set)
    __swig_setmethods__["voiceBeginnings"] = _CsoundAC.CounterpointNode_voiceBeginnings_set
    __swig_getmethods__["voiceBeginnings"] = _CsoundAC.CounterpointNode_voiceBeginnings_get
    if _newclass:
        voiceBeginnings = _swig_property(_CsoundAC.CounterpointNode_voiceBeginnings_get, _CsoundAC.CounterpointNode_voiceBeginnings_set)

    def __init__(self):
        """__init__(csound::CounterpointNode self) -> CounterpointNode"""
        this = _CsoundAC.new_CounterpointNode()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_CounterpointNode
    __del__ = lambda self: None

    def produceOrTransform(self, score, beginAt, endAt, globalCoordinates):
        """produceOrTransform(CounterpointNode self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & globalCoordinates)"""
        return _CsoundAC.CounterpointNode_produceOrTransform(self, score, beginAt, endAt, globalCoordinates)

CounterpointNode_swigregister = _CsoundAC.CounterpointNode_swigregister
CounterpointNode_swigregister(CounterpointNode)

class ScoreNode(Node):
    """Proxy of C++ csound::ScoreNode class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreNode, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["duration"] = _CsoundAC.ScoreNode_duration_set
    __swig_getmethods__["duration"] = _CsoundAC.ScoreNode_duration_get
    if _newclass:
        duration = _swig_property(_CsoundAC.ScoreNode_duration_get, _CsoundAC.ScoreNode_duration_set)
    __swig_setmethods__["importFilename"] = _CsoundAC.ScoreNode_importFilename_set
    __swig_getmethods__["importFilename"] = _CsoundAC.ScoreNode_importFilename_get
    if _newclass:
        importFilename = _swig_property(_CsoundAC.ScoreNode_importFilename_get, _CsoundAC.ScoreNode_importFilename_set)

    def __init__(self):
        """__init__(csound::ScoreNode self) -> ScoreNode"""
        this = _CsoundAC.new_ScoreNode()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ScoreNode
    __del__ = lambda self: None

    def produceOrTransform(self, collectingScore, beginAt, endAt, coordinates):
        """produceOrTransform(ScoreNode self, Score collectingScore, size_t beginAt, size_t endAt, Eigen::MatrixXd const & coordinates)"""
        return _CsoundAC.ScoreNode_produceOrTransform(self, collectingScore, beginAt, endAt, coordinates)


    def getScore(self):
        """getScore(ScoreNode self) -> Score"""
        return _CsoundAC.ScoreNode_getScore(self)

ScoreNode_swigregister = _CsoundAC.ScoreNode_swigregister
ScoreNode_swigregister(ScoreNode)

class Cell(ScoreNode):
    """Proxy of C++ csound::Cell class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cell, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cell, name)
    __repr__ = _swig_repr
    __swig_setmethods__["repeatCount"] = _CsoundAC.Cell_repeatCount_set
    __swig_getmethods__["repeatCount"] = _CsoundAC.Cell_repeatCount_get
    if _newclass:
        repeatCount = _swig_property(_CsoundAC.Cell_repeatCount_get, _CsoundAC.Cell_repeatCount_set)
    __swig_setmethods__["relativeDuration"] = _CsoundAC.Cell_relativeDuration_set
    __swig_getmethods__["relativeDuration"] = _CsoundAC.Cell_relativeDuration_get
    if _newclass:
        relativeDuration = _swig_property(_CsoundAC.Cell_relativeDuration_get, _CsoundAC.Cell_relativeDuration_set)
    __swig_setmethods__["durationSeconds"] = _CsoundAC.Cell_durationSeconds_set
    __swig_getmethods__["durationSeconds"] = _CsoundAC.Cell_durationSeconds_get
    if _newclass:
        durationSeconds = _swig_property(_CsoundAC.Cell_durationSeconds_get, _CsoundAC.Cell_durationSeconds_set)

    def __init__(self):
        """__init__(csound::Cell self) -> Cell"""
        this = _CsoundAC.new_Cell()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Cell
    __del__ = lambda self: None

    def produceOrTransform(self, collectingScore, beginAt, endAt, coordinates):
        """produceOrTransform(Cell self, Score collectingScore, size_t beginAt, size_t endAt, Eigen::MatrixXd const & coordinates)"""
        return _CsoundAC.Cell_produceOrTransform(self, collectingScore, beginAt, endAt, coordinates)

Cell_swigregister = _CsoundAC.Cell_swigregister
Cell_swigregister(Cell)

class Intercut(ScoreNode):
    """Proxy of C++ csound::Intercut class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Intercut, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Intercut, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Intercut self) -> Intercut"""
        this = _CsoundAC.new_Intercut()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Intercut
    __del__ = lambda self: None

    def traverse(self, globalCoordinates, collectingScore):
        """traverse(Intercut self, Eigen::MatrixXd const & globalCoordinates, Score collectingScore) -> Eigen::MatrixXd"""
        return _CsoundAC.Intercut_traverse(self, globalCoordinates, collectingScore)

Intercut_swigregister = _CsoundAC.Intercut_swigregister
Intercut_swigregister(Intercut)

class Stack(ScoreNode):
    """Proxy of C++ csound::Stack class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Stack, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Stack, name)
    __repr__ = _swig_repr
    __swig_setmethods__["duration"] = _CsoundAC.Stack_duration_set
    __swig_getmethods__["duration"] = _CsoundAC.Stack_duration_get
    if _newclass:
        duration = _swig_property(_CsoundAC.Stack_duration_get, _CsoundAC.Stack_duration_set)

    def __init__(self):
        """__init__(csound::Stack self) -> Stack"""
        this = _CsoundAC.new_Stack()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Stack
    __del__ = lambda self: None

    def traverse(self, globalCoordinates, collectingScore):
        """traverse(Stack self, Eigen::MatrixXd const & globalCoordinates, Score collectingScore) -> Eigen::MatrixXd"""
        return _CsoundAC.Stack_traverse(self, globalCoordinates, collectingScore)

Stack_swigregister = _CsoundAC.Stack_swigregister
Stack_swigregister(Stack)

class Koch(ScoreNode):
    """Proxy of C++ csound::Koch class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Koch, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Koch, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pitchOffsetsForLayers"] = _CsoundAC.Koch_pitchOffsetsForLayers_set
    __swig_getmethods__["pitchOffsetsForLayers"] = _CsoundAC.Koch_pitchOffsetsForLayers_get
    if _newclass:
        pitchOffsetsForLayers = _swig_property(_CsoundAC.Koch_pitchOffsetsForLayers_get, _CsoundAC.Koch_pitchOffsetsForLayers_set)

    def __init__(self):
        """__init__(csound::Koch self) -> Koch"""
        this = _CsoundAC.new_Koch()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Koch
    __del__ = lambda self: None

    def traverse(self, globalCoordinates, collectingScore):
        """traverse(Koch self, Eigen::MatrixXd const & globalCoordinates, Score collectingScore) -> Eigen::MatrixXd"""
        return _CsoundAC.Koch_traverse(self, globalCoordinates, collectingScore)


    def setPitchOffsetForLayer(self, layer, pitch):
        """setPitchOffsetForLayer(Koch self, int layer, double pitch)"""
        return _CsoundAC.Koch_setPitchOffsetForLayer(self, layer, pitch)

Koch_swigregister = _CsoundAC.Koch_swigregister
Koch_swigregister(Koch)

class Hocket(ScoreNode):
    """Proxy of C++ csound::Hocket class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hocket, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Hocket, name)
    __repr__ = _swig_repr
    __swig_setmethods__["modulus"] = _CsoundAC.Hocket_modulus_set
    __swig_getmethods__["modulus"] = _CsoundAC.Hocket_modulus_get
    if _newclass:
        modulus = _swig_property(_CsoundAC.Hocket_modulus_get, _CsoundAC.Hocket_modulus_set)
    __swig_setmethods__["startingIndex"] = _CsoundAC.Hocket_startingIndex_set
    __swig_getmethods__["startingIndex"] = _CsoundAC.Hocket_startingIndex_get
    if _newclass:
        startingIndex = _swig_property(_CsoundAC.Hocket_startingIndex_get, _CsoundAC.Hocket_startingIndex_set)

    def __init__(self):
        """__init__(csound::Hocket self) -> Hocket"""
        this = _CsoundAC.new_Hocket()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Hocket
    __del__ = lambda self: None

    def traverse(self, globalCoordinates, collectingScore):
        """traverse(Hocket self, Eigen::MatrixXd const & globalCoordinates, Score collectingScore) -> Eigen::MatrixXd"""
        return _CsoundAC.Hocket_traverse(self, globalCoordinates, collectingScore)

Hocket_swigregister = _CsoundAC.Hocket_swigregister
Hocket_swigregister(Hocket)

class Rescale(ScoreNode):
    """Proxy of C++ csound::Rescale class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rescale, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Rescale, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Rescale self) -> Rescale"""
        this = _CsoundAC.new_Rescale()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Rescale
    __del__ = lambda self: None

    def initialize(self):
        """initialize(Rescale self)"""
        return _CsoundAC.Rescale_initialize(self)


    def produceOrTransform(self, score, beginAt, endAt, coordinates):
        """produceOrTransform(Rescale self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & coordinates)"""
        return _CsoundAC.Rescale_produceOrTransform(self, score, beginAt, endAt, coordinates)


    def setRescale(self, dimension, rescaleMinimum, rescaleRange, targetMinimum, targetRange):
        """setRescale(Rescale self, int dimension, bool rescaleMinimum, bool rescaleRange, double targetMinimum, double targetRange)"""
        return _CsoundAC.Rescale_setRescale(self, dimension, rescaleMinimum, rescaleRange, targetMinimum, targetRange)


    def getRescale(self, dimension, rescaleMinimum, rescaleRange, targetMinimum, targetRange):
        """getRescale(Rescale self, int dimension, bool & rescaleMinimum, bool & rescaleRange, double & targetMinimum, double & targetRange)"""
        return _CsoundAC.Rescale_getRescale(self, dimension, rescaleMinimum, rescaleRange, targetMinimum, targetRange)

Rescale_swigregister = _CsoundAC.Rescale_swigregister
Rescale_swigregister(Rescale)

class ScoreModel(Composition, Node):
    """Proxy of C++ csound::ScoreModel class."""

    __swig_setmethods__ = {}
    for _s in [Composition, Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreModel, name, value)
    __swig_getmethods__ = {}
    for _s in [Composition, Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreModel, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::ScoreModel self) -> ScoreModel"""
        this = _CsoundAC.new_ScoreModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ScoreModel
    __del__ = lambda self: None

    def initialize(self):
        """initialize(ScoreModel self)"""
        return _CsoundAC.ScoreModel_initialize(self)


    def generate(self):
        """generate(ScoreModel self) -> int"""
        return _CsoundAC.ScoreModel_generate(self)


    def clear(self):
        """clear(ScoreModel self)"""
        return _CsoundAC.ScoreModel_clear(self)


    def getThis(self):
        """getThis(ScoreModel self) -> intptr_t"""
        return _CsoundAC.ScoreModel_getThis(self)


    def getThisNode(self):
        """getThisNode(ScoreModel self) -> Node"""
        return _CsoundAC.ScoreModel_getThisNode(self)

ScoreModel_swigregister = _CsoundAC.ScoreModel_swigregister
ScoreModel_swigregister(ScoreModel)

class MusicModel(ScoreModel):
    """Proxy of C++ csound::MusicModel class."""

    __swig_setmethods__ = {}
    for _s in [ScoreModel]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MusicModel, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreModel]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MusicModel, name)
    __repr__ = _swig_repr
    __swig_setmethods__["threadCount"] = _CsoundAC.MusicModel_threadCount_set
    __swig_getmethods__["threadCount"] = _CsoundAC.MusicModel_threadCount_get
    if _newclass:
        threadCount = _swig_property(_CsoundAC.MusicModel_threadCount_get, _CsoundAC.MusicModel_threadCount_set)

    def __init__(self):
        """__init__(csound::MusicModel self) -> MusicModel"""
        this = _CsoundAC.new_MusicModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MusicModel
    __del__ = lambda self: None

    def initialize(self):
        """initialize(MusicModel self)"""
        return _CsoundAC.MusicModel_initialize(self)


    def generate(self):
        """generate(MusicModel self) -> int"""
        return _CsoundAC.MusicModel_generate(self)


    def getThis(self):
        """getThis(MusicModel self) -> intptr_t"""
        return _CsoundAC.MusicModel_getThis(self)


    def getThisNode(self):
        """getThisNode(MusicModel self) -> Node"""
        return _CsoundAC.MusicModel_getThisNode(self)


    def createCsoundScore(self, *args):
        """
        createCsoundScore(MusicModel self, std::string addToScore, double extendSeconds=5.0)
        createCsoundScore(MusicModel self, std::string addToScore)
        createCsoundScore(MusicModel self)
        """
        return _CsoundAC.MusicModel_createCsoundScore(self, *args)


    def render(self):
        """render(MusicModel self) -> int"""
        return _CsoundAC.MusicModel_render(self)


    def stop(self):
        """stop(MusicModel self)"""
        return _CsoundAC.MusicModel_stop(self)


    def perform(self):
        """perform(MusicModel self) -> int"""
        return _CsoundAC.MusicModel_perform(self)


    def clear(self):
        """clear(MusicModel self)"""
        return _CsoundAC.MusicModel_clear(self)


    def setCppSound(self, orchestra):
        """setCppSound(MusicModel self, CppSound * orchestra)"""
        return _CsoundAC.MusicModel_setCppSound(self, orchestra)


    def getCppSound(self):
        """getCppSound(MusicModel self) -> CppSound *"""
        return _CsoundAC.MusicModel_getCppSound(self)


    def setCsoundOrchestra(self, orchestra):
        """setCsoundOrchestra(MusicModel self, std::string orchestra)"""
        return _CsoundAC.MusicModel_setCsoundOrchestra(self, orchestra)


    def getCsoundOrchestra(self):
        """getCsoundOrchestra(MusicModel self) -> std::string"""
        return _CsoundAC.MusicModel_getCsoundOrchestra(self)


    def setCsoundScoreHeader(self, header):
        """setCsoundScoreHeader(MusicModel self, std::string header)"""
        return _CsoundAC.MusicModel_setCsoundScoreHeader(self, header)


    def getCsoundScoreHeader(self):
        """getCsoundScoreHeader(MusicModel self) -> std::string"""
        return _CsoundAC.MusicModel_getCsoundScoreHeader(self)


    def arrange(self, *args):
        """
        arrange(MusicModel self, int oldInstrumentNumber, int newInstrumentNumber)
        arrange(MusicModel self, int oldInstrumentNumber, int newInstrumentNumber, double gain)
        arrange(MusicModel self, int oldInstrumentNumber, int newInstrumentNumber, double gain, double pan)
        arrange(MusicModel self, int silenceInstrumentNumber, std::string csoundInstrumentName)
        arrange(MusicModel self, int silenceInstrumentNumber, std::string csoundInstrumentName, double gain)
        arrange(MusicModel self, int silenceInstrumentNumber, std::string csoundInstrumentName, double gain, double pan)
        """
        return _CsoundAC.MusicModel_arrange(self, *args)


    def removeArrangement(self):
        """removeArrangement(MusicModel self)"""
        return _CsoundAC.MusicModel_removeArrangement(self)


    def setCsoundCommand(self, command):
        """setCsoundCommand(MusicModel self, std::string command)"""
        return _CsoundAC.MusicModel_setCsoundCommand(self, command)


    def getCsoundCommand(self):
        """getCsoundCommand(MusicModel self) -> std::string"""
        return _CsoundAC.MusicModel_getCsoundCommand(self)


    def processArgs(self, args):
        """processArgs(MusicModel self, std::vector< std::string,std::allocator< std::string > > const & args) -> int"""
        return _CsoundAC.MusicModel_processArgs(self, args)

MusicModel_swigregister = _CsoundAC.MusicModel_swigregister
MusicModel_swigregister(MusicModel)

class Sequence(Node):
    """Proxy of C++ csound::Sequence class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sequence, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Sequence, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Sequence self) -> Sequence"""
        this = _CsoundAC.new_Sequence()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Sequence
    __del__ = lambda self: None

    def traverse(self, globalCoordinates, score):
        """traverse(Sequence self, Eigen::MatrixXd const & globalCoordinates, Score score) -> Eigen::MatrixXd"""
        return _CsoundAC.Sequence_traverse(self, globalCoordinates, score)

Sequence_swigregister = _CsoundAC.Sequence_swigregister
Sequence_swigregister(Sequence)

class Random(Node):
    """Proxy of C++ csound::Random class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Random, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Random, name)
    __repr__ = _swig_repr
    __swig_setmethods__["distribution"] = _CsoundAC.Random_distribution_set
    __swig_getmethods__["distribution"] = _CsoundAC.Random_distribution_get
    if _newclass:
        distribution = _swig_property(_CsoundAC.Random_distribution_get, _CsoundAC.Random_distribution_set)
    __swig_setmethods__["row"] = _CsoundAC.Random_row_set
    __swig_getmethods__["row"] = _CsoundAC.Random_row_get
    if _newclass:
        row = _swig_property(_CsoundAC.Random_row_get, _CsoundAC.Random_row_set)
    __swig_setmethods__["column"] = _CsoundAC.Random_column_set
    __swig_getmethods__["column"] = _CsoundAC.Random_column_get
    if _newclass:
        column = _swig_property(_CsoundAC.Random_column_get, _CsoundAC.Random_column_set)
    __swig_setmethods__["eventCount"] = _CsoundAC.Random_eventCount_set
    __swig_getmethods__["eventCount"] = _CsoundAC.Random_eventCount_get
    if _newclass:
        eventCount = _swig_property(_CsoundAC.Random_eventCount_get, _CsoundAC.Random_eventCount_set)
    __swig_setmethods__["incrementTime"] = _CsoundAC.Random_incrementTime_set
    __swig_getmethods__["incrementTime"] = _CsoundAC.Random_incrementTime_get
    if _newclass:
        incrementTime = _swig_property(_CsoundAC.Random_incrementTime_get, _CsoundAC.Random_incrementTime_set)
    __swig_setmethods__["minimum"] = _CsoundAC.Random_minimum_set
    __swig_getmethods__["minimum"] = _CsoundAC.Random_minimum_get
    if _newclass:
        minimum = _swig_property(_CsoundAC.Random_minimum_get, _CsoundAC.Random_minimum_set)
    __swig_setmethods__["maximum"] = _CsoundAC.Random_maximum_set
    __swig_getmethods__["maximum"] = _CsoundAC.Random_maximum_get
    if _newclass:
        maximum = _swig_property(_CsoundAC.Random_maximum_get, _CsoundAC.Random_maximum_set)
    __swig_setmethods__["q"] = _CsoundAC.Random_q_set
    __swig_getmethods__["q"] = _CsoundAC.Random_q_get
    if _newclass:
        q = _swig_property(_CsoundAC.Random_q_get, _CsoundAC.Random_q_set)
    __swig_setmethods__["a"] = _CsoundAC.Random_a_set
    __swig_getmethods__["a"] = _CsoundAC.Random_a_get
    if _newclass:
        a = _swig_property(_CsoundAC.Random_a_get, _CsoundAC.Random_a_set)
    __swig_setmethods__["b"] = _CsoundAC.Random_b_set
    __swig_getmethods__["b"] = _CsoundAC.Random_b_get
    if _newclass:
        b = _swig_property(_CsoundAC.Random_b_get, _CsoundAC.Random_b_set)
    __swig_setmethods__["c"] = _CsoundAC.Random_c_set
    __swig_getmethods__["c"] = _CsoundAC.Random_c_get
    if _newclass:
        c = _swig_property(_CsoundAC.Random_c_get, _CsoundAC.Random_c_set)
    __swig_setmethods__["Lambda"] = _CsoundAC.Random_Lambda_set
    __swig_getmethods__["Lambda"] = _CsoundAC.Random_Lambda_get
    if _newclass:
        Lambda = _swig_property(_CsoundAC.Random_Lambda_get, _CsoundAC.Random_Lambda_set)
    __swig_setmethods__["mean"] = _CsoundAC.Random_mean_set
    __swig_getmethods__["mean"] = _CsoundAC.Random_mean_get
    if _newclass:
        mean = _swig_property(_CsoundAC.Random_mean_get, _CsoundAC.Random_mean_set)
    __swig_setmethods__["sigma"] = _CsoundAC.Random_sigma_set
    __swig_getmethods__["sigma"] = _CsoundAC.Random_sigma_get
    if _newclass:
        sigma = _swig_property(_CsoundAC.Random_sigma_get, _CsoundAC.Random_sigma_set)

    def __init__(self):
        """__init__(csound::Random self) -> Random"""
        this = _CsoundAC.new_Random()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Random
    __del__ = lambda self: None

    def sample(self):
        """sample(Random self) -> double"""
        return _CsoundAC.Random_sample(self)


    def getRandomCoordinates(self):
        """getRandomCoordinates(Random self) -> Eigen::MatrixXd"""
        return _CsoundAC.Random_getRandomCoordinates(self)


    def createDistribution(self, distribution):
        """createDistribution(Random self, std::string distribution)"""
        return _CsoundAC.Random_createDistribution(self, distribution)


    def produceOrTransform(self, score, beginAt, endAt, compositeCoordinates):
        """produceOrTransform(Random self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & compositeCoordinates)"""
        return _CsoundAC.Random_produceOrTransform(self, score, beginAt, endAt, compositeCoordinates)


    def seed(s):
        """seed(int s)"""
        return _CsoundAC.Random_seed(s)

    seed = staticmethod(seed)
Random_swigregister = _CsoundAC.Random_swigregister
Random_swigregister(Random)

def Random_seed(s):
    """Random_seed(int s)"""
    return _CsoundAC.Random_seed(s)

class ImageToScore(ScoreNode):
    """Proxy of C++ csound::ImageToScore class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageToScore, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImageToScore, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::ImageToScore self) -> ImageToScore"""
        this = _CsoundAC.new_ImageToScore()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ImageToScore
    __del__ = lambda self: None

    def setImageFilename(self, imageFilename):
        """setImageFilename(ImageToScore self, std::string imageFilename)"""
        return _CsoundAC.ImageToScore_setImageFilename(self, imageFilename)


    def getImageFilename(self):
        """getImageFilename(ImageToScore self) -> std::string"""
        return _CsoundAC.ImageToScore_getImageFilename(self)


    def setMaximumVoiceCount(self, maximumVoiceCount):
        """setMaximumVoiceCount(ImageToScore self, size_t maximumVoiceCount)"""
        return _CsoundAC.ImageToScore_setMaximumVoiceCount(self, maximumVoiceCount)


    def getMaximumVoiceCount(self):
        """getMaximumVoiceCount(ImageToScore self) -> size_t"""
        return _CsoundAC.ImageToScore_getMaximumVoiceCount(self)


    def setMinimumValue(self, minimumValue):
        """setMinimumValue(ImageToScore self, double minimumValue)"""
        return _CsoundAC.ImageToScore_setMinimumValue(self, minimumValue)


    def getMinimumValue(self):
        """getMinimumValue(ImageToScore self) -> double"""
        return _CsoundAC.ImageToScore_getMinimumValue(self)


    def generate(self):
        """generate(ImageToScore self)"""
        return _CsoundAC.ImageToScore_generate(self)

ImageToScore_swigregister = _CsoundAC.ImageToScore_swigregister
ImageToScore_swigregister(ImageToScore)

class StrangeAttractor(ScoreNode):
    """Proxy of C++ csound::StrangeAttractor class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrangeAttractor, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StrangeAttractor, name)
    __repr__ = _swig_repr
    __swig_setmethods__["randomNode"] = _CsoundAC.StrangeAttractor_randomNode_set
    __swig_getmethods__["randomNode"] = _CsoundAC.StrangeAttractor_randomNode_get
    if _newclass:
        randomNode = _swig_property(_CsoundAC.StrangeAttractor_randomNode_get, _CsoundAC.StrangeAttractor_randomNode_set)

    def __init__(self):
        """__init__(csound::StrangeAttractor self) -> StrangeAttractor"""
        this = _CsoundAC.new_StrangeAttractor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_StrangeAttractor
    __del__ = lambda self: None

    def setCode(self, code):
        """setCode(StrangeAttractor self, std::string code)"""
        return _CsoundAC.StrangeAttractor_setCode(self, code)


    def getCode(self):
        """getCode(StrangeAttractor self) -> std::string"""
        return _CsoundAC.StrangeAttractor_getCode(self)


    def setIterationCount(self, iterationCount):
        """setIterationCount(StrangeAttractor self, size_t iterationCount)"""
        return _CsoundAC.StrangeAttractor_setIterationCount(self, iterationCount)


    def getIterationCount(self):
        """getIterationCount(StrangeAttractor self) -> size_t"""
        return _CsoundAC.StrangeAttractor_getIterationCount(self)


    def setIteration(self, iteration):
        """setIteration(StrangeAttractor self, size_t iteration)"""
        return _CsoundAC.StrangeAttractor_setIteration(self, iteration)


    def getIteration(self):
        """getIteration(StrangeAttractor self) -> size_t"""
        return _CsoundAC.StrangeAttractor_getIteration(self)


    def setAttractorType(self, attractorType):
        """setAttractorType(StrangeAttractor self, int attractorType)"""
        return _CsoundAC.StrangeAttractor_setAttractorType(self, attractorType)


    def getAttractorType(self):
        """getAttractorType(StrangeAttractor self) -> int"""
        return _CsoundAC.StrangeAttractor_getAttractorType(self)


    def setScoreType(self, attractorType):
        """setScoreType(StrangeAttractor self, int attractorType)"""
        return _CsoundAC.StrangeAttractor_setScoreType(self, attractorType)


    def getScoreType(self):
        """getScoreType(StrangeAttractor self) -> int"""
        return _CsoundAC.StrangeAttractor_getScoreType(self)


    def initialize(self):
        """initialize(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_initialize(self)


    def reinitialize(self):
        """reinitialize(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_reinitialize(self)


    def reset(self):
        """reset(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_reset(self)


    def codeRandomize(self):
        """codeRandomize(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_codeRandomize(self)


    def specialFunctions(self):
        """specialFunctions(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_specialFunctions(self)


    def getDimensionAndOrder(self):
        """getDimensionAndOrder(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_getDimensionAndOrder(self)


    def getCoefficients(self):
        """getCoefficients(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_getCoefficients(self)


    def shuffleRandomNumbers(self):
        """shuffleRandomNumbers(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_shuffleRandomNumbers(self)


    def calculateLyupanovExponent(self):
        """calculateLyupanovExponent(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_calculateLyupanovExponent(self)


    def calculateFractalDimension(self):
        """calculateFractalDimension(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_calculateFractalDimension(self)


    def getFractalDimension(self):
        """getFractalDimension(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getFractalDimension(self)


    def getLyupanovExponent(self):
        """getLyupanovExponent(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getLyupanovExponent(self)


    def setX(self, X):
        """setX(StrangeAttractor self, double X)"""
        return _CsoundAC.StrangeAttractor_setX(self, X)


    def getX(self):
        """getX(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getX(self)


    def setY(self, X):
        """setY(StrangeAttractor self, double X)"""
        return _CsoundAC.StrangeAttractor_setY(self, X)


    def getY(self):
        """getY(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getY(self)


    def setZ(self, X):
        """setZ(StrangeAttractor self, double X)"""
        return _CsoundAC.StrangeAttractor_setZ(self, X)


    def getZ(self):
        """getZ(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getZ(self)


    def setW(self, X):
        """setW(StrangeAttractor self, double X)"""
        return _CsoundAC.StrangeAttractor_setW(self, X)


    def getW(self):
        """getW(StrangeAttractor self) -> double"""
        return _CsoundAC.StrangeAttractor_getW(self)


    def searchForAttractor(self):
        """searchForAttractor(StrangeAttractor self) -> bool"""
        return _CsoundAC.StrangeAttractor_searchForAttractor(self)


    def evaluateAttractor(self):
        """evaluateAttractor(StrangeAttractor self) -> bool"""
        return _CsoundAC.StrangeAttractor_evaluateAttractor(self)


    def iterate(self):
        """iterate(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_iterate(self)


    def generate(self):
        """generate(StrangeAttractor self)"""
        return _CsoundAC.StrangeAttractor_generate(self)


    def render(self, N, X, Y, Z, W):
        """render(StrangeAttractor self, int N, double X, double Y, double Z, double W)"""
        return _CsoundAC.StrangeAttractor_render(self, N, X, Y, Z, W)


    def setDimensionCount(self, D):
        """setDimensionCount(StrangeAttractor self, int D)"""
        return _CsoundAC.StrangeAttractor_setDimensionCount(self, D)


    def getDimensionCount(self):
        """getDimensionCount(StrangeAttractor self) -> int"""
        return _CsoundAC.StrangeAttractor_getDimensionCount(self)

StrangeAttractor_swigregister = _CsoundAC.StrangeAttractor_swigregister
StrangeAttractor_swigregister(StrangeAttractor)

class Lindenmayer(ScoreNode):
    """Proxy of C++ csound::Lindenmayer class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Lindenmayer, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Lindenmayer, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Lindenmayer self) -> Lindenmayer"""
        this = _CsoundAC.new_Lindenmayer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Lindenmayer
    __del__ = lambda self: None

    def getIterationCount(self):
        """getIterationCount(Lindenmayer self) -> int"""
        return _CsoundAC.Lindenmayer_getIterationCount(self)


    def setIterationCount(self, count):
        """setIterationCount(Lindenmayer self, int count)"""
        return _CsoundAC.Lindenmayer_setIterationCount(self, count)


    def getAngle(self):
        """getAngle(Lindenmayer self) -> double"""
        return _CsoundAC.Lindenmayer_getAngle(self)


    def setAngle(self, angle):
        """setAngle(Lindenmayer self, double angle)"""
        return _CsoundAC.Lindenmayer_setAngle(self, angle)


    def getAxiom(self):
        """getAxiom(Lindenmayer self) -> std::string"""
        return _CsoundAC.Lindenmayer_getAxiom(self)


    def setAxiom(self, axiom):
        """setAxiom(Lindenmayer self, std::string axiom)"""
        return _CsoundAC.Lindenmayer_setAxiom(self, axiom)


    def addRule(self, command, replacement):
        """addRule(Lindenmayer self, std::string command, std::string replacement)"""
        return _CsoundAC.Lindenmayer_addRule(self, command, replacement)


    def getReplacement(self, command):
        """getReplacement(Lindenmayer self, std::string command) -> std::string"""
        return _CsoundAC.Lindenmayer_getReplacement(self, command)


    def generate(self):
        """generate(Lindenmayer self)"""
        return _CsoundAC.Lindenmayer_generate(self)


    def clear(self):
        """clear(Lindenmayer self)"""
        return _CsoundAC.Lindenmayer_clear(self)

Lindenmayer_swigregister = _CsoundAC.Lindenmayer_swigregister
Lindenmayer_swigregister(Lindenmayer)

class MCRM(ScoreNode):
    """Proxy of C++ csound::MCRM class."""

    __swig_setmethods__ = {}
    for _s in [ScoreNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCRM, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCRM, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::MCRM self) -> MCRM"""
        this = _CsoundAC.new_MCRM()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_MCRM
    __del__ = lambda self: None

    def setDepth(self, depth):
        """setDepth(MCRM self, int depth)"""
        return _CsoundAC.MCRM_setDepth(self, depth)


    def resize(self, transformations):
        """resize(MCRM self, size_t transformations)"""
        return _CsoundAC.MCRM_resize(self, transformations)


    def setTransformationElement(self, index, row, column, value):
        """setTransformationElement(MCRM self, size_t index, size_t row, size_t column, double value)"""
        return _CsoundAC.MCRM_setTransformationElement(self, index, row, column, value)


    def setWeight(self, precursor, successor, weight):
        """setWeight(MCRM self, size_t precursor, size_t successor, double weight)"""
        return _CsoundAC.MCRM_setWeight(self, precursor, successor, weight)


    def generate(self):
        """generate(MCRM self)"""
        return _CsoundAC.MCRM_generate(self)


    def produceOrTransform(self, score, beginAt, endAt, coordinates):
        """produceOrTransform(MCRM self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & coordinates)"""
        return _CsoundAC.MCRM_produceOrTransform(self, score, beginAt, endAt, coordinates)

MCRM_swigregister = _CsoundAC.MCRM_swigregister
MCRM_swigregister(MCRM)

class Soundfile(_object):
    """Proxy of C++ csound::Soundfile class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Soundfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Soundfile, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::Soundfile self) -> Soundfile"""
        this = _CsoundAC.new_Soundfile()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Soundfile
    __del__ = lambda self: None

    def getFramesPerSecond(self):
        """getFramesPerSecond(Soundfile self) -> int"""
        return _CsoundAC.Soundfile_getFramesPerSecond(self)


    def setFramesPerSecond(self, framesPerSecond):
        """setFramesPerSecond(Soundfile self, int framesPerSecond)"""
        return _CsoundAC.Soundfile_setFramesPerSecond(self, framesPerSecond)


    def getChannelsPerFrame(self):
        """getChannelsPerFrame(Soundfile self) -> int"""
        return _CsoundAC.Soundfile_getChannelsPerFrame(self)


    def setChannelsPerFrame(self, channelsPerFrame):
        """setChannelsPerFrame(Soundfile self, int channelsPerFrame)"""
        return _CsoundAC.Soundfile_setChannelsPerFrame(self, channelsPerFrame)


    def getFormat(self):
        """getFormat(Soundfile self) -> int"""
        return _CsoundAC.Soundfile_getFormat(self)


    def setFormat(self, format):
        """setFormat(Soundfile self, int format)"""
        return _CsoundAC.Soundfile_setFormat(self, format)


    def getFrames(self):
        """getFrames(Soundfile self) -> int"""
        return _CsoundAC.Soundfile_getFrames(self)


    def open(self, filename):
        """open(Soundfile self, std::string filename) -> int"""
        return _CsoundAC.Soundfile_open(self, filename)


    def create(self, *args):
        """
        create(Soundfile self, std::string filename, int framesPerSecond=44100, int channelsPerFrame=2, int format) -> int
        create(Soundfile self, std::string filename, int framesPerSecond=44100, int channelsPerFrame=2) -> int
        create(Soundfile self, std::string filename, int framesPerSecond=44100) -> int
        create(Soundfile self, std::string filename) -> int
        """
        return _CsoundAC.Soundfile_create(self, *args)


    def seek(self, frames, whence=0):
        """
        seek(Soundfile self, int frames, int whence=0) -> int
        seek(Soundfile self, int frames) -> int
        """
        return _CsoundAC.Soundfile_seek(self, frames, whence)


    def seekSeconds(self, seconds, whence=0):
        """
        seekSeconds(Soundfile self, double seconds, int whence=0) -> double
        seekSeconds(Soundfile self, double seconds) -> double
        """
        return _CsoundAC.Soundfile_seekSeconds(self, seconds, whence)


    def readFrame(self, outputFrame):
        """readFrame(Soundfile self, double * outputFrame) -> int"""
        return _CsoundAC.Soundfile_readFrame(self, outputFrame)


    def writeFrame(self, inputFrame):
        """writeFrame(Soundfile self, double * inputFrame) -> int"""
        return _CsoundAC.Soundfile_writeFrame(self, inputFrame)


    def readFrames(self, outputFrames):
        """readFrames(Soundfile self, double * outputFrames) -> int"""
        return _CsoundAC.Soundfile_readFrames(self, outputFrames)


    def writeFrames(self, inputFrames):
        """writeFrames(Soundfile self, double * inputFrames) -> int"""
        return _CsoundAC.Soundfile_writeFrames(self, inputFrames)


    def mixFrames(self, inputFrames, mixedFrames):
        """mixFrames(Soundfile self, double * inputFrames, double * mixedFrames) -> int"""
        return _CsoundAC.Soundfile_mixFrames(self, inputFrames, mixedFrames)


    def updateHeader(self):
        """updateHeader(Soundfile self)"""
        return _CsoundAC.Soundfile_updateHeader(self)


    def close(self):
        """close(Soundfile self) -> int"""
        return _CsoundAC.Soundfile_close(self)


    def error(self):
        """error(Soundfile self)"""
        return _CsoundAC.Soundfile_error(self)


    def blank(self, duration):
        """blank(Soundfile self, double duration)"""
        return _CsoundAC.Soundfile_blank(self, duration)


    def jonesParksGrain(self, centerTimeSeconds, durationSeconds, beginningFrequencyHz, centerFrequencyHz, centerAmplitude, centerPhaseOffsetRadians, pan, synchronousPhase=True, buffer=False):
        """
        jonesParksGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double beginningFrequencyHz, double centerFrequencyHz, double centerAmplitude, double centerPhaseOffsetRadians, double pan, bool synchronousPhase=True, bool buffer=False)
        jonesParksGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double beginningFrequencyHz, double centerFrequencyHz, double centerAmplitude, double centerPhaseOffsetRadians, double pan, bool synchronousPhase=True)
        jonesParksGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double beginningFrequencyHz, double centerFrequencyHz, double centerAmplitude, double centerPhaseOffsetRadians, double pan)
        """
        return _CsoundAC.Soundfile_jonesParksGrain(self, centerTimeSeconds, durationSeconds, beginningFrequencyHz, centerFrequencyHz, centerAmplitude, centerPhaseOffsetRadians, pan, synchronousPhase, buffer)


    def cosineGrain(self, centerTimeSeconds, durationSeconds, frequencyHz, amplitude, phaseOffsetRadians, pan, synchronousPhase=True, buffer=False):
        """
        cosineGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double frequencyHz, double amplitude, double phaseOffsetRadians, double pan, bool synchronousPhase=True, bool buffer=False)
        cosineGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double frequencyHz, double amplitude, double phaseOffsetRadians, double pan, bool synchronousPhase=True)
        cosineGrain(Soundfile self, double centerTimeSeconds, double durationSeconds, double frequencyHz, double amplitude, double phaseOffsetRadians, double pan)
        """
        return _CsoundAC.Soundfile_cosineGrain(self, centerTimeSeconds, durationSeconds, frequencyHz, amplitude, phaseOffsetRadians, pan, synchronousPhase, buffer)


    def mixGrain(self):
        """mixGrain(Soundfile self)"""
        return _CsoundAC.Soundfile_mixGrain(self)

Soundfile_swigregister = _CsoundAC.Soundfile_swigregister
Soundfile_swigregister(Soundfile)

class ChordVector(_object):
    """Proxy of C++ std::vector<(std::vector<(double)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChordVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChordVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ChordVector self) -> SwigPyIterator"""
        return _CsoundAC.ChordVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ChordVector self) -> bool"""
        return _CsoundAC.ChordVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ChordVector self) -> bool"""
        return _CsoundAC.ChordVector___bool__(self)


    def __len__(self):
        """__len__(ChordVector self) -> std::vector< std::vector< double > >::size_type"""
        return _CsoundAC.ChordVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ChordVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> ChordVector"""
        return _CsoundAC.ChordVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ChordVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
        __setslice__(ChordVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, ChordVector v)
        """
        return _CsoundAC.ChordVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ChordVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
        return _CsoundAC.ChordVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ChordVector self, std::vector< std::vector< double > >::difference_type i)
        __delitem__(ChordVector self, PySliceObject * slice)
        """
        return _CsoundAC.ChordVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ChordVector self, PySliceObject * slice) -> ChordVector
        __getitem__(ChordVector self, std::vector< std::vector< double > >::difference_type i) -> DoubleVector
        """
        return _CsoundAC.ChordVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ChordVector self, PySliceObject * slice, ChordVector v)
        __setitem__(ChordVector self, PySliceObject * slice)
        __setitem__(ChordVector self, std::vector< std::vector< double > >::difference_type i, DoubleVector x)
        """
        return _CsoundAC.ChordVector___setitem__(self, *args)


    def pop(self):
        """pop(ChordVector self) -> DoubleVector"""
        return _CsoundAC.ChordVector_pop(self)


    def append(self, x):
        """append(ChordVector self, DoubleVector x)"""
        return _CsoundAC.ChordVector_append(self, x)


    def empty(self):
        """empty(ChordVector self) -> bool"""
        return _CsoundAC.ChordVector_empty(self)


    def size(self):
        """size(ChordVector self) -> std::vector< std::vector< double > >::size_type"""
        return _CsoundAC.ChordVector_size(self)


    def swap(self, v):
        """swap(ChordVector self, ChordVector v)"""
        return _CsoundAC.ChordVector_swap(self, v)


    def begin(self):
        """begin(ChordVector self) -> std::vector< std::vector< double > >::iterator"""
        return _CsoundAC.ChordVector_begin(self)


    def end(self):
        """end(ChordVector self) -> std::vector< std::vector< double > >::iterator"""
        return _CsoundAC.ChordVector_end(self)


    def rbegin(self):
        """rbegin(ChordVector self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _CsoundAC.ChordVector_rbegin(self)


    def rend(self):
        """rend(ChordVector self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _CsoundAC.ChordVector_rend(self)


    def clear(self):
        """clear(ChordVector self)"""
        return _CsoundAC.ChordVector_clear(self)


    def get_allocator(self):
        """get_allocator(ChordVector self) -> std::vector< std::vector< double > >::allocator_type"""
        return _CsoundAC.ChordVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ChordVector self)"""
        return _CsoundAC.ChordVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ChordVector self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
        erase(ChordVector self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
        """
        return _CsoundAC.ChordVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(double)>)> self) -> ChordVector
        __init__(std::vector<(std::vector<(double)>)> self, ChordVector arg2) -> ChordVector
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size) -> ChordVector
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size, DoubleVector value) -> ChordVector
        """
        this = _CsoundAC.new_ChordVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ChordVector self, DoubleVector x)"""
        return _CsoundAC.ChordVector_push_back(self, x)


    def front(self):
        """front(ChordVector self) -> DoubleVector"""
        return _CsoundAC.ChordVector_front(self)


    def back(self):
        """back(ChordVector self) -> DoubleVector"""
        return _CsoundAC.ChordVector_back(self)


    def assign(self, n, x):
        """assign(ChordVector self, std::vector< std::vector< double > >::size_type n, DoubleVector x)"""
        return _CsoundAC.ChordVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ChordVector self, std::vector< std::vector< double > >::size_type new_size)
        resize(ChordVector self, std::vector< std::vector< double > >::size_type new_size, DoubleVector x)
        """
        return _CsoundAC.ChordVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ChordVector self, std::vector< std::vector< double > >::iterator pos, DoubleVector x) -> std::vector< std::vector< double > >::iterator
        insert(ChordVector self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, DoubleVector x)
        """
        return _CsoundAC.ChordVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ChordVector self, std::vector< std::vector< double > >::size_type n)"""
        return _CsoundAC.ChordVector_reserve(self, n)


    def capacity(self):
        """capacity(ChordVector self) -> std::vector< std::vector< double > >::size_type"""
        return _CsoundAC.ChordVector_capacity(self)

    __swig_destroy__ = _CsoundAC.delete_ChordVector
    __del__ = lambda self: None
ChordVector_swigregister = _CsoundAC.ChordVector_swigregister
ChordVector_swigregister(ChordVector)

class Voicelead(_object):
    """Proxy of C++ csound::Voicelead class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Voicelead, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Voicelead, name)
    __repr__ = _swig_repr

    def pc(pitch, divisionsPerOctave=12):
        """
        pc(double pitch, size_t divisionsPerOctave=12) -> double
        pc(double pitch) -> double
        """
        return _CsoundAC.Voicelead_pc(pitch, divisionsPerOctave)

    pc = staticmethod(pc)

    def voiceleading(chord1, chord2):
        """voiceleading(DoubleVector chord1, DoubleVector chord2) -> DoubleVector"""
        return _CsoundAC.Voicelead_voiceleading(chord1, chord2)

    voiceleading = staticmethod(voiceleading)

    def simpler(source, destination1, destination2, avoidParallels):
        """simpler(DoubleVector source, DoubleVector destination1, DoubleVector destination2, bool avoidParallels) -> DoubleVector"""
        return _CsoundAC.Voicelead_simpler(source, destination1, destination2, avoidParallels)

    simpler = staticmethod(simpler)

    def smoothness(chord1, chord2):
        """smoothness(DoubleVector chord1, DoubleVector chord2) -> double"""
        return _CsoundAC.Voicelead_smoothness(chord1, chord2)

    smoothness = staticmethod(smoothness)

    def euclideanDistance(chord1, chord2):
        """euclideanDistance(DoubleVector chord1, DoubleVector chord2) -> double"""
        return _CsoundAC.Voicelead_euclideanDistance(chord1, chord2)

    euclideanDistance = staticmethod(euclideanDistance)

    def areParallel(chord1, chord2):
        """areParallel(DoubleVector chord1, DoubleVector chord2) -> bool"""
        return _CsoundAC.Voicelead_areParallel(chord1, chord2)

    areParallel = staticmethod(areParallel)

    def closer(source, destination1, destination2, avoidParallels):
        """closer(DoubleVector source, DoubleVector destination1, DoubleVector destination2, bool avoidParallels) -> DoubleVector"""
        return _CsoundAC.Voicelead_closer(source, destination1, destination2, avoidParallels)

    closer = staticmethod(closer)

    def rotate(chord):
        """rotate(DoubleVector chord) -> DoubleVector"""
        return _CsoundAC.Voicelead_rotate(chord)

    rotate = staticmethod(rotate)

    def rotations(chord):
        """rotations(DoubleVector chord) -> ChordVector"""
        return _CsoundAC.Voicelead_rotations(chord)

    rotations = staticmethod(rotations)

    def pcs(chord, divisionsPerOctave=12):
        """
        pcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
        pcs(DoubleVector chord) -> DoubleVector
        """
        return _CsoundAC.Voicelead_pcs(chord, divisionsPerOctave)

    pcs = staticmethod(pcs)

    def uniquePcs(chord, divisionsPerOctave=12):
        """
        uniquePcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
        uniquePcs(DoubleVector chord) -> DoubleVector
        """
        return _CsoundAC.Voicelead_uniquePcs(chord, divisionsPerOctave)

    uniquePcs = staticmethod(uniquePcs)

    def pitchClassSetToM(chord, divisionsPerOctave=12):
        """
        pitchClassSetToM(DoubleVector chord, size_t divisionsPerOctave=12) -> double
        pitchClassSetToM(DoubleVector chord) -> double
        """
        return _CsoundAC.Voicelead_pitchClassSetToM(chord, divisionsPerOctave)

    pitchClassSetToM = staticmethod(pitchClassSetToM)

    def mToPitchClassSet(pcn, divisionsPerOctave=12):
        """
        mToPitchClassSet(double pcn, size_t divisionsPerOctave=12) -> DoubleVector
        mToPitchClassSet(double pcn) -> DoubleVector
        """
        return _CsoundAC.Voicelead_mToPitchClassSet(pcn, divisionsPerOctave)

    mToPitchClassSet = staticmethod(mToPitchClassSet)

    def pitchClassSetToPandT(pcs, divisionsPerOctave=12):
        """
        pitchClassSetToPandT(DoubleVector pcs, size_t divisionsPerOctave=12) -> DoubleVector
        pitchClassSetToPandT(DoubleVector pcs) -> DoubleVector
        """
        return _CsoundAC.Voicelead_pitchClassSetToPandT(pcs, divisionsPerOctave)

    pitchClassSetToPandT = staticmethod(pitchClassSetToPandT)

    def pAndTtoPitchClassSet(prime, transposition, divisionsPerOctave=12):
        """
        pAndTtoPitchClassSet(double prime, double transposition, size_t divisionsPerOctave=12) -> DoubleVector
        pAndTtoPitchClassSet(double prime, double transposition) -> DoubleVector
        """
        return _CsoundAC.Voicelead_pAndTtoPitchClassSet(prime, transposition, divisionsPerOctave)

    pAndTtoPitchClassSet = staticmethod(pAndTtoPitchClassSet)

    def closest(source, destinations, avoidParallels):
        """closest(DoubleVector source, ChordVector destinations, bool avoidParallels) -> DoubleVector"""
        return _CsoundAC.Voicelead_closest(source, destinations, avoidParallels)

    closest = staticmethod(closest)

    def voicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave=12):
        """
        voicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels, size_t divisionsPerOctave=12) -> DoubleVector
        voicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels) -> DoubleVector
        """
        return _CsoundAC.Voicelead_voicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave)

    voicelead = staticmethod(voicelead)

    def recursiveVoicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave=12):
        """
        recursiveVoicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels, size_t divisionsPerOctave=12) -> DoubleVector
        recursiveVoicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels) -> DoubleVector
        """
        return _CsoundAC.Voicelead_recursiveVoicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave)

    recursiveVoicelead = staticmethod(recursiveVoicelead)

    def closestPitch(pitch, pitches):
        """closestPitch(double pitch, DoubleVector pitches) -> double"""
        return _CsoundAC.Voicelead_closestPitch(pitch, pitches)

    closestPitch = staticmethod(closestPitch)

    def conformToPitchClassSet(pitch, pcs, divisionsPerOctave=12):
        """
        conformToPitchClassSet(double pitch, DoubleVector pcs, size_t divisionsPerOctave=12) -> double
        conformToPitchClassSet(double pitch, DoubleVector pcs) -> double
        """
        return _CsoundAC.Voicelead_conformToPitchClassSet(pitch, pcs, divisionsPerOctave)

    conformToPitchClassSet = staticmethod(conformToPitchClassSet)

    def invert(chord):
        """invert(DoubleVector chord) -> DoubleVector"""
        return _CsoundAC.Voicelead_invert(chord)

    invert = staticmethod(invert)

    def inversions(chord):
        """inversions(DoubleVector chord) -> ChordVector"""
        return _CsoundAC.Voicelead_inversions(chord)

    inversions = staticmethod(inversions)

    def toOrigin(chord):
        """toOrigin(DoubleVector chord) -> DoubleVector"""
        return _CsoundAC.Voicelead_toOrigin(chord)

    toOrigin = staticmethod(toOrigin)

    def normalChord(chord):
        """normalChord(DoubleVector chord) -> DoubleVector"""
        return _CsoundAC.Voicelead_normalChord(chord)

    normalChord = staticmethod(normalChord)

    def primeChord(chord):
        """primeChord(DoubleVector chord) -> DoubleVector"""
        return _CsoundAC.Voicelead_primeChord(chord)

    primeChord = staticmethod(primeChord)

    def nameToC(name, divisionsPerOctave_):
        """nameToC(std::string name, size_t divisionsPerOctave_) -> double"""
        return _CsoundAC.Voicelead_nameToC(name, divisionsPerOctave_)

    nameToC = staticmethod(nameToC)

    def mToC(M, divisionsPerOctave):
        """mToC(double M, size_t divisionsPerOctave) -> double"""
        return _CsoundAC.Voicelead_mToC(M, divisionsPerOctave)

    mToC = staticmethod(mToC)

    def cToM(C, divisionsPerOctaven=12):
        """
        cToM(double C, size_t divisionsPerOctaven=12) -> double
        cToM(double C) -> double
        """
        return _CsoundAC.Voicelead_cToM(C, divisionsPerOctaven)

    cToM = staticmethod(cToM)

    def cToP(C, divisionsPerOctave=12):
        """
        cToP(double C, size_t divisionsPerOctave=12) -> double
        cToP(double C) -> double
        """
        return _CsoundAC.Voicelead_cToP(C, divisionsPerOctave)

    cToP = staticmethod(cToP)

    def pToC(Z, divisionsPerOctave=12):
        """
        pToC(double Z, size_t divisionsPerOctave=12) -> double
        pToC(double Z) -> double
        """
        return _CsoundAC.Voicelead_pToC(Z, divisionsPerOctave)

    pToC = staticmethod(pToC)

    def orderedPcs(chord, divisionsPerOctave=12):
        """
        orderedPcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
        orderedPcs(DoubleVector chord) -> DoubleVector
        """
        return _CsoundAC.Voicelead_orderedPcs(chord, divisionsPerOctave)

    orderedPcs = staticmethod(orderedPcs)

    def sortByAscendingDistance(chord, divisionsPerOctave=12):
        """
        sortByAscendingDistance(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
        sortByAscendingDistance(DoubleVector chord) -> DoubleVector
        """
        return _CsoundAC.Voicelead_sortByAscendingDistance(chord, divisionsPerOctave)

    sortByAscendingDistance = staticmethod(sortByAscendingDistance)

    def nonBijectiveVoicelead(sourceChord, targetPitchClassSet, divisionsPerOctave=12):
        """
        nonBijectiveVoicelead(DoubleVector sourceChord, DoubleVector targetPitchClassSet, size_t divisionsPerOctave=12) -> ChordVector
        nonBijectiveVoicelead(DoubleVector sourceChord, DoubleVector targetPitchClassSet) -> ChordVector
        """
        return _CsoundAC.Voicelead_nonBijectiveVoicelead(sourceChord, targetPitchClassSet, divisionsPerOctave)

    nonBijectiveVoicelead = staticmethod(nonBijectiveVoicelead)

    def pToPrimeChord(P, divisionsPerOctave=12):
        """
        pToPrimeChord(double P, size_t divisionsPerOctave=12) -> DoubleVector
        pToPrimeChord(double P) -> DoubleVector
        """
        return _CsoundAC.Voicelead_pToPrimeChord(P, divisionsPerOctave)

    pToPrimeChord = staticmethod(pToPrimeChord)

    def initializePrimeChordsForDivisionsPerOctave(divisionsPerOctave):
        """initializePrimeChordsForDivisionsPerOctave(size_t divisionsPerOctave)"""
        return _CsoundAC.Voicelead_initializePrimeChordsForDivisionsPerOctave(divisionsPerOctave)

    initializePrimeChordsForDivisionsPerOctave = staticmethod(initializePrimeChordsForDivisionsPerOctave)

    def ptvToChord(P, T, V_, lowest, range, divisionsPerOctave=12):
        """
        ptvToChord(size_t P, size_t T, size_t V_, size_t lowest, size_t range, size_t divisionsPerOctave=12) -> DoubleVector
        ptvToChord(size_t P, size_t T, size_t V_, size_t lowest, size_t range) -> DoubleVector
        """
        return _CsoundAC.Voicelead_ptvToChord(P, T, V_, lowest, range, divisionsPerOctave)

    ptvToChord = staticmethod(ptvToChord)

    def chordToPTV(chord, lowestPitch, highestPitch, divisionsPerOctave=12):
        """
        chordToPTV(DoubleVector chord, size_t lowestPitch, size_t highestPitch, size_t divisionsPerOctave=12) -> DoubleVector
        chordToPTV(DoubleVector chord, size_t lowestPitch, size_t highestPitch) -> DoubleVector
        """
        return _CsoundAC.Voicelead_chordToPTV(chord, lowestPitch, highestPitch, divisionsPerOctave)

    chordToPTV = staticmethod(chordToPTV)

    def voicings(chord, lowest, highest, divisionsPerOctave):
        """voicings(DoubleVector chord, double lowest, double highest, size_t divisionsPerOctave) -> ChordVector"""
        return _CsoundAC.Voicelead_voicings(chord, lowest, highest, divisionsPerOctave)

    voicings = staticmethod(voicings)

    def addOctave(lowestVoicing, newVoicing, maximumPitch, divisionsPerOctave):
        """addOctave(DoubleVector lowestVoicing, DoubleVector newVoicing, size_t maximumPitch, size_t divisionsPerOctave) -> bool"""
        return _CsoundAC.Voicelead_addOctave(lowestVoicing, newVoicing, maximumPitch, divisionsPerOctave)

    addOctave = staticmethod(addOctave)

    def wrap(chord, lowestPitch, highestPitch, divisionsPerOctave=12):
        """
        wrap(DoubleVector chord, size_t lowestPitch, size_t highestPitch, size_t divisionsPerOctave=12) -> DoubleVector
        wrap(DoubleVector chord, size_t lowestPitch, size_t highestPitch) -> DoubleVector
        """
        return _CsoundAC.Voicelead_wrap(chord, lowestPitch, highestPitch, divisionsPerOctave)

    wrap = staticmethod(wrap)

    def transpose(chord, semitones):
        """transpose(DoubleVector chord, double semitones) -> DoubleVector"""
        return _CsoundAC.Voicelead_transpose(chord, semitones)

    transpose = staticmethod(transpose)

    def T(*args):
        """
        T(double p, double n) -> double
        T(DoubleVector c, double n) -> DoubleVector
        """
        return _CsoundAC.Voicelead_T(*args)

    T = staticmethod(T)

    def I(*args):
        """
        I(double p, double n) -> double
        I(DoubleVector c, double n) -> DoubleVector
        """
        return _CsoundAC.Voicelead_I(*args)

    I = staticmethod(I)

    def K(c):
        """K(DoubleVector c) -> DoubleVector"""
        return _CsoundAC.Voicelead_K(c)

    K = staticmethod(K)

    def Tform(X, Y, g=1.0):
        """
        Tform(DoubleVector X, DoubleVector Y, double g=1.0) -> bool
        Tform(DoubleVector X, DoubleVector Y) -> bool
        """
        return _CsoundAC.Voicelead_Tform(X, Y, g)

    Tform = staticmethod(Tform)

    def Iform(X, Y, g=1.0):
        """
        Iform(DoubleVector X, DoubleVector Y, double g=1.0) -> bool
        Iform(DoubleVector X, DoubleVector Y) -> bool
        """
        return _CsoundAC.Voicelead_Iform(X, Y, g)

    Iform = staticmethod(Iform)

    def Q(c, n, s, g=1.0):
        """
        Q(DoubleVector c, double n, DoubleVector s, double g=1.0) -> DoubleVector
        Q(DoubleVector c, double n, DoubleVector s) -> DoubleVector
        """
        return _CsoundAC.Voicelead_Q(c, n, s, g)

    Q = staticmethod(Q)

    def __init__(self):
        """__init__(csound::Voicelead self) -> Voicelead"""
        this = _CsoundAC.new_Voicelead()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Voicelead
    __del__ = lambda self: None
Voicelead_swigregister = _CsoundAC.Voicelead_swigregister
Voicelead_swigregister(Voicelead)

def Voicelead_pc(pitch, divisionsPerOctave=12):
    """
    pc(double pitch, size_t divisionsPerOctave=12) -> double
    Voicelead_pc(double pitch) -> double
    """
    return _CsoundAC.Voicelead_pc(pitch, divisionsPerOctave)

def Voicelead_voiceleading(chord1, chord2):
    """Voicelead_voiceleading(DoubleVector chord1, DoubleVector chord2) -> DoubleVector"""
    return _CsoundAC.Voicelead_voiceleading(chord1, chord2)

def Voicelead_simpler(source, destination1, destination2, avoidParallels):
    """Voicelead_simpler(DoubleVector source, DoubleVector destination1, DoubleVector destination2, bool avoidParallels) -> DoubleVector"""
    return _CsoundAC.Voicelead_simpler(source, destination1, destination2, avoidParallels)

def Voicelead_smoothness(chord1, chord2):
    """Voicelead_smoothness(DoubleVector chord1, DoubleVector chord2) -> double"""
    return _CsoundAC.Voicelead_smoothness(chord1, chord2)

def Voicelead_euclideanDistance(chord1, chord2):
    """Voicelead_euclideanDistance(DoubleVector chord1, DoubleVector chord2) -> double"""
    return _CsoundAC.Voicelead_euclideanDistance(chord1, chord2)

def Voicelead_areParallel(chord1, chord2):
    """Voicelead_areParallel(DoubleVector chord1, DoubleVector chord2) -> bool"""
    return _CsoundAC.Voicelead_areParallel(chord1, chord2)

def Voicelead_closer(source, destination1, destination2, avoidParallels):
    """Voicelead_closer(DoubleVector source, DoubleVector destination1, DoubleVector destination2, bool avoidParallels) -> DoubleVector"""
    return _CsoundAC.Voicelead_closer(source, destination1, destination2, avoidParallels)

def Voicelead_rotate(chord):
    """Voicelead_rotate(DoubleVector chord) -> DoubleVector"""
    return _CsoundAC.Voicelead_rotate(chord)

def Voicelead_rotations(chord):
    """Voicelead_rotations(DoubleVector chord) -> ChordVector"""
    return _CsoundAC.Voicelead_rotations(chord)

def Voicelead_pcs(chord, divisionsPerOctave=12):
    """
    pcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_pcs(DoubleVector chord) -> DoubleVector
    """
    return _CsoundAC.Voicelead_pcs(chord, divisionsPerOctave)

def Voicelead_uniquePcs(chord, divisionsPerOctave=12):
    """
    uniquePcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_uniquePcs(DoubleVector chord) -> DoubleVector
    """
    return _CsoundAC.Voicelead_uniquePcs(chord, divisionsPerOctave)

def Voicelead_pitchClassSetToM(chord, divisionsPerOctave=12):
    """
    pitchClassSetToM(DoubleVector chord, size_t divisionsPerOctave=12) -> double
    Voicelead_pitchClassSetToM(DoubleVector chord) -> double
    """
    return _CsoundAC.Voicelead_pitchClassSetToM(chord, divisionsPerOctave)

def Voicelead_mToPitchClassSet(pcn, divisionsPerOctave=12):
    """
    mToPitchClassSet(double pcn, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_mToPitchClassSet(double pcn) -> DoubleVector
    """
    return _CsoundAC.Voicelead_mToPitchClassSet(pcn, divisionsPerOctave)

def Voicelead_pitchClassSetToPandT(pcs, divisionsPerOctave=12):
    """
    pitchClassSetToPandT(DoubleVector pcs, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_pitchClassSetToPandT(DoubleVector pcs) -> DoubleVector
    """
    return _CsoundAC.Voicelead_pitchClassSetToPandT(pcs, divisionsPerOctave)

def Voicelead_pAndTtoPitchClassSet(prime, transposition, divisionsPerOctave=12):
    """
    pAndTtoPitchClassSet(double prime, double transposition, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_pAndTtoPitchClassSet(double prime, double transposition) -> DoubleVector
    """
    return _CsoundAC.Voicelead_pAndTtoPitchClassSet(prime, transposition, divisionsPerOctave)

def Voicelead_closest(source, destinations, avoidParallels):
    """Voicelead_closest(DoubleVector source, ChordVector destinations, bool avoidParallels) -> DoubleVector"""
    return _CsoundAC.Voicelead_closest(source, destinations, avoidParallels)

def Voicelead_voicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave=12):
    """
    voicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_voicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels) -> DoubleVector
    """
    return _CsoundAC.Voicelead_voicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave)

def Voicelead_recursiveVoicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave=12):
    """
    recursiveVoicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_recursiveVoicelead(DoubleVector source, DoubleVector targetPitchClassSet, double lowest, double range, bool avoidParallels) -> DoubleVector
    """
    return _CsoundAC.Voicelead_recursiveVoicelead(source, targetPitchClassSet, lowest, range, avoidParallels, divisionsPerOctave)

def Voicelead_closestPitch(pitch, pitches):
    """Voicelead_closestPitch(double pitch, DoubleVector pitches) -> double"""
    return _CsoundAC.Voicelead_closestPitch(pitch, pitches)

def Voicelead_conformToPitchClassSet(pitch, pcs, divisionsPerOctave=12):
    """
    conformToPitchClassSet(double pitch, DoubleVector pcs, size_t divisionsPerOctave=12) -> double
    Voicelead_conformToPitchClassSet(double pitch, DoubleVector pcs) -> double
    """
    return _CsoundAC.Voicelead_conformToPitchClassSet(pitch, pcs, divisionsPerOctave)

def Voicelead_invert(chord):
    """Voicelead_invert(DoubleVector chord) -> DoubleVector"""
    return _CsoundAC.Voicelead_invert(chord)

def Voicelead_inversions(chord):
    """Voicelead_inversions(DoubleVector chord) -> ChordVector"""
    return _CsoundAC.Voicelead_inversions(chord)

def Voicelead_toOrigin(chord):
    """Voicelead_toOrigin(DoubleVector chord) -> DoubleVector"""
    return _CsoundAC.Voicelead_toOrigin(chord)

def Voicelead_normalChord(chord):
    """Voicelead_normalChord(DoubleVector chord) -> DoubleVector"""
    return _CsoundAC.Voicelead_normalChord(chord)

def Voicelead_primeChord(chord):
    """Voicelead_primeChord(DoubleVector chord) -> DoubleVector"""
    return _CsoundAC.Voicelead_primeChord(chord)

def Voicelead_nameToC(name, divisionsPerOctave_):
    """Voicelead_nameToC(std::string name, size_t divisionsPerOctave_) -> double"""
    return _CsoundAC.Voicelead_nameToC(name, divisionsPerOctave_)

def Voicelead_mToC(M, divisionsPerOctave):
    """Voicelead_mToC(double M, size_t divisionsPerOctave) -> double"""
    return _CsoundAC.Voicelead_mToC(M, divisionsPerOctave)

def Voicelead_cToM(C, divisionsPerOctaven=12):
    """
    cToM(double C, size_t divisionsPerOctaven=12) -> double
    Voicelead_cToM(double C) -> double
    """
    return _CsoundAC.Voicelead_cToM(C, divisionsPerOctaven)

def Voicelead_cToP(C, divisionsPerOctave=12):
    """
    cToP(double C, size_t divisionsPerOctave=12) -> double
    Voicelead_cToP(double C) -> double
    """
    return _CsoundAC.Voicelead_cToP(C, divisionsPerOctave)

def Voicelead_pToC(Z, divisionsPerOctave=12):
    """
    pToC(double Z, size_t divisionsPerOctave=12) -> double
    Voicelead_pToC(double Z) -> double
    """
    return _CsoundAC.Voicelead_pToC(Z, divisionsPerOctave)

def Voicelead_orderedPcs(chord, divisionsPerOctave=12):
    """
    orderedPcs(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_orderedPcs(DoubleVector chord) -> DoubleVector
    """
    return _CsoundAC.Voicelead_orderedPcs(chord, divisionsPerOctave)

def Voicelead_sortByAscendingDistance(chord, divisionsPerOctave=12):
    """
    sortByAscendingDistance(DoubleVector chord, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_sortByAscendingDistance(DoubleVector chord) -> DoubleVector
    """
    return _CsoundAC.Voicelead_sortByAscendingDistance(chord, divisionsPerOctave)

def Voicelead_nonBijectiveVoicelead(sourceChord, targetPitchClassSet, divisionsPerOctave=12):
    """
    nonBijectiveVoicelead(DoubleVector sourceChord, DoubleVector targetPitchClassSet, size_t divisionsPerOctave=12) -> ChordVector
    Voicelead_nonBijectiveVoicelead(DoubleVector sourceChord, DoubleVector targetPitchClassSet) -> ChordVector
    """
    return _CsoundAC.Voicelead_nonBijectiveVoicelead(sourceChord, targetPitchClassSet, divisionsPerOctave)

def Voicelead_pToPrimeChord(P, divisionsPerOctave=12):
    """
    pToPrimeChord(double P, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_pToPrimeChord(double P) -> DoubleVector
    """
    return _CsoundAC.Voicelead_pToPrimeChord(P, divisionsPerOctave)

def Voicelead_initializePrimeChordsForDivisionsPerOctave(divisionsPerOctave):
    """Voicelead_initializePrimeChordsForDivisionsPerOctave(size_t divisionsPerOctave)"""
    return _CsoundAC.Voicelead_initializePrimeChordsForDivisionsPerOctave(divisionsPerOctave)

def Voicelead_ptvToChord(P, T, V_, lowest, range, divisionsPerOctave=12):
    """
    ptvToChord(size_t P, size_t T, size_t V_, size_t lowest, size_t range, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_ptvToChord(size_t P, size_t T, size_t V_, size_t lowest, size_t range) -> DoubleVector
    """
    return _CsoundAC.Voicelead_ptvToChord(P, T, V_, lowest, range, divisionsPerOctave)

def Voicelead_chordToPTV(chord, lowestPitch, highestPitch, divisionsPerOctave=12):
    """
    chordToPTV(DoubleVector chord, size_t lowestPitch, size_t highestPitch, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_chordToPTV(DoubleVector chord, size_t lowestPitch, size_t highestPitch) -> DoubleVector
    """
    return _CsoundAC.Voicelead_chordToPTV(chord, lowestPitch, highestPitch, divisionsPerOctave)

def Voicelead_voicings(chord, lowest, highest, divisionsPerOctave):
    """Voicelead_voicings(DoubleVector chord, double lowest, double highest, size_t divisionsPerOctave) -> ChordVector"""
    return _CsoundAC.Voicelead_voicings(chord, lowest, highest, divisionsPerOctave)

def Voicelead_addOctave(lowestVoicing, newVoicing, maximumPitch, divisionsPerOctave):
    """Voicelead_addOctave(DoubleVector lowestVoicing, DoubleVector newVoicing, size_t maximumPitch, size_t divisionsPerOctave) -> bool"""
    return _CsoundAC.Voicelead_addOctave(lowestVoicing, newVoicing, maximumPitch, divisionsPerOctave)

def Voicelead_wrap(chord, lowestPitch, highestPitch, divisionsPerOctave=12):
    """
    wrap(DoubleVector chord, size_t lowestPitch, size_t highestPitch, size_t divisionsPerOctave=12) -> DoubleVector
    Voicelead_wrap(DoubleVector chord, size_t lowestPitch, size_t highestPitch) -> DoubleVector
    """
    return _CsoundAC.Voicelead_wrap(chord, lowestPitch, highestPitch, divisionsPerOctave)

def Voicelead_transpose(chord, semitones):
    """Voicelead_transpose(DoubleVector chord, double semitones) -> DoubleVector"""
    return _CsoundAC.Voicelead_transpose(chord, semitones)

def Voicelead_T(*args):
    """
    T(double p, double n) -> double
    Voicelead_T(DoubleVector c, double n) -> DoubleVector
    """
    return _CsoundAC.Voicelead_T(*args)

def Voicelead_I(*args):
    """
    I(double p, double n) -> double
    Voicelead_I(DoubleVector c, double n) -> DoubleVector
    """
    return _CsoundAC.Voicelead_I(*args)

def Voicelead_K(c):
    """Voicelead_K(DoubleVector c) -> DoubleVector"""
    return _CsoundAC.Voicelead_K(c)

def Voicelead_Tform(X, Y, g=1.0):
    """
    Tform(DoubleVector X, DoubleVector Y, double g=1.0) -> bool
    Voicelead_Tform(DoubleVector X, DoubleVector Y) -> bool
    """
    return _CsoundAC.Voicelead_Tform(X, Y, g)

def Voicelead_Iform(X, Y, g=1.0):
    """
    Iform(DoubleVector X, DoubleVector Y, double g=1.0) -> bool
    Voicelead_Iform(DoubleVector X, DoubleVector Y) -> bool
    """
    return _CsoundAC.Voicelead_Iform(X, Y, g)

def Voicelead_Q(c, n, s, g=1.0):
    """
    Q(DoubleVector c, double n, DoubleVector s, double g=1.0) -> DoubleVector
    Voicelead_Q(DoubleVector c, double n, DoubleVector s) -> DoubleVector
    """
    return _CsoundAC.Voicelead_Q(c, n, s, g)
cvar = _CsoundAC.cvar
Voicelead.semitonesPerOctave = _CsoundAC.cvar.Voicelead_semitonesPerOctave

class VoiceleadingOperation(_object):
    """Proxy of C++ csound::VoiceleadingOperation class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VoiceleadingOperation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VoiceleadingOperation, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::VoiceleadingOperation self) -> VoiceleadingOperation"""
        this = _CsoundAC.new_VoiceleadingOperation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_VoiceleadingOperation
    __del__ = lambda self: None
    __swig_setmethods__["beginTime"] = _CsoundAC.VoiceleadingOperation_beginTime_set
    __swig_getmethods__["beginTime"] = _CsoundAC.VoiceleadingOperation_beginTime_get
    if _newclass:
        beginTime = _swig_property(_CsoundAC.VoiceleadingOperation_beginTime_get, _CsoundAC.VoiceleadingOperation_beginTime_set)
    __swig_setmethods__["rescaledBeginTime"] = _CsoundAC.VoiceleadingOperation_rescaledBeginTime_set
    __swig_getmethods__["rescaledBeginTime"] = _CsoundAC.VoiceleadingOperation_rescaledBeginTime_get
    if _newclass:
        rescaledBeginTime = _swig_property(_CsoundAC.VoiceleadingOperation_rescaledBeginTime_get, _CsoundAC.VoiceleadingOperation_rescaledBeginTime_set)
    __swig_setmethods__["endTime"] = _CsoundAC.VoiceleadingOperation_endTime_set
    __swig_getmethods__["endTime"] = _CsoundAC.VoiceleadingOperation_endTime_get
    if _newclass:
        endTime = _swig_property(_CsoundAC.VoiceleadingOperation_endTime_get, _CsoundAC.VoiceleadingOperation_endTime_set)
    __swig_setmethods__["rescaledEndTime"] = _CsoundAC.VoiceleadingOperation_rescaledEndTime_set
    __swig_getmethods__["rescaledEndTime"] = _CsoundAC.VoiceleadingOperation_rescaledEndTime_get
    if _newclass:
        rescaledEndTime = _swig_property(_CsoundAC.VoiceleadingOperation_rescaledEndTime_get, _CsoundAC.VoiceleadingOperation_rescaledEndTime_set)
    __swig_setmethods__["P_"] = _CsoundAC.VoiceleadingOperation_P__set
    __swig_getmethods__["P_"] = _CsoundAC.VoiceleadingOperation_P__get
    if _newclass:
        P_ = _swig_property(_CsoundAC.VoiceleadingOperation_P__get, _CsoundAC.VoiceleadingOperation_P__set)
    __swig_setmethods__["T_"] = _CsoundAC.VoiceleadingOperation_T__set
    __swig_getmethods__["T_"] = _CsoundAC.VoiceleadingOperation_T__get
    if _newclass:
        T_ = _swig_property(_CsoundAC.VoiceleadingOperation_T__get, _CsoundAC.VoiceleadingOperation_T__set)
    __swig_setmethods__["C_"] = _CsoundAC.VoiceleadingOperation_C__set
    __swig_getmethods__["C_"] = _CsoundAC.VoiceleadingOperation_C__get
    if _newclass:
        C_ = _swig_property(_CsoundAC.VoiceleadingOperation_C__get, _CsoundAC.VoiceleadingOperation_C__set)
    __swig_setmethods__["K_"] = _CsoundAC.VoiceleadingOperation_K__set
    __swig_getmethods__["K_"] = _CsoundAC.VoiceleadingOperation_K__get
    if _newclass:
        K_ = _swig_property(_CsoundAC.VoiceleadingOperation_K__get, _CsoundAC.VoiceleadingOperation_K__set)
    __swig_setmethods__["Q_"] = _CsoundAC.VoiceleadingOperation_Q__set
    __swig_getmethods__["Q_"] = _CsoundAC.VoiceleadingOperation_Q__get
    if _newclass:
        Q_ = _swig_property(_CsoundAC.VoiceleadingOperation_Q__get, _CsoundAC.VoiceleadingOperation_Q__set)
    __swig_setmethods__["V_"] = _CsoundAC.VoiceleadingOperation_V__set
    __swig_getmethods__["V_"] = _CsoundAC.VoiceleadingOperation_V__get
    if _newclass:
        V_ = _swig_property(_CsoundAC.VoiceleadingOperation_V__get, _CsoundAC.VoiceleadingOperation_V__set)
    __swig_setmethods__["L_"] = _CsoundAC.VoiceleadingOperation_L__set
    __swig_getmethods__["L_"] = _CsoundAC.VoiceleadingOperation_L__get
    if _newclass:
        L_ = _swig_property(_CsoundAC.VoiceleadingOperation_L__get, _CsoundAC.VoiceleadingOperation_L__set)
    __swig_setmethods__["begin"] = _CsoundAC.VoiceleadingOperation_begin_set
    __swig_getmethods__["begin"] = _CsoundAC.VoiceleadingOperation_begin_get
    if _newclass:
        begin = _swig_property(_CsoundAC.VoiceleadingOperation_begin_get, _CsoundAC.VoiceleadingOperation_begin_set)
    __swig_setmethods__["end"] = _CsoundAC.VoiceleadingOperation_end_set
    __swig_getmethods__["end"] = _CsoundAC.VoiceleadingOperation_end_get
    if _newclass:
        end = _swig_property(_CsoundAC.VoiceleadingOperation_end_get, _CsoundAC.VoiceleadingOperation_end_set)
    __swig_setmethods__["avoidParallels"] = _CsoundAC.VoiceleadingOperation_avoidParallels_set
    __swig_getmethods__["avoidParallels"] = _CsoundAC.VoiceleadingOperation_avoidParallels_get
    if _newclass:
        avoidParallels = _swig_property(_CsoundAC.VoiceleadingOperation_avoidParallels_get, _CsoundAC.VoiceleadingOperation_avoidParallels_set)
VoiceleadingOperation_swigregister = _CsoundAC.VoiceleadingOperation_swigregister
VoiceleadingOperation_swigregister(VoiceleadingOperation)


def __lshift__(stream, operation):
    """__lshift__(std::ostream & stream, VoiceleadingOperation operation) -> std::ostream &"""
    return _CsoundAC.__lshift__(stream, operation)
class VoiceleadingNode(Node):
    """Proxy of C++ csound::VoiceleadingNode class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VoiceleadingNode, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VoiceleadingNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["operations"] = _CsoundAC.VoiceleadingNode_operations_set
    __swig_getmethods__["operations"] = _CsoundAC.VoiceleadingNode_operations_get
    if _newclass:
        operations = _swig_property(_CsoundAC.VoiceleadingNode_operations_get, _CsoundAC.VoiceleadingNode_operations_set)
    __swig_setmethods__["base"] = _CsoundAC.VoiceleadingNode_base_set
    __swig_getmethods__["base"] = _CsoundAC.VoiceleadingNode_base_get
    if _newclass:
        base = _swig_property(_CsoundAC.VoiceleadingNode_base_get, _CsoundAC.VoiceleadingNode_base_set)
    __swig_setmethods__["range"] = _CsoundAC.VoiceleadingNode_range_set
    __swig_getmethods__["range"] = _CsoundAC.VoiceleadingNode_range_get
    if _newclass:
        range = _swig_property(_CsoundAC.VoiceleadingNode_range_get, _CsoundAC.VoiceleadingNode_range_set)
    __swig_setmethods__["modality"] = _CsoundAC.VoiceleadingNode_modality_set
    __swig_getmethods__["modality"] = _CsoundAC.VoiceleadingNode_modality_get
    if _newclass:
        modality = _swig_property(_CsoundAC.VoiceleadingNode_modality_get, _CsoundAC.VoiceleadingNode_modality_set)
    __swig_setmethods__["rescaleTimes"] = _CsoundAC.VoiceleadingNode_rescaleTimes_set
    __swig_getmethods__["rescaleTimes"] = _CsoundAC.VoiceleadingNode_rescaleTimes_get
    if _newclass:
        rescaleTimes = _swig_property(_CsoundAC.VoiceleadingNode_rescaleTimes_get, _CsoundAC.VoiceleadingNode_rescaleTimes_set)
    __swig_setmethods__["avoidParallels"] = _CsoundAC.VoiceleadingNode_avoidParallels_set
    __swig_getmethods__["avoidParallels"] = _CsoundAC.VoiceleadingNode_avoidParallels_get
    if _newclass:
        avoidParallels = _swig_property(_CsoundAC.VoiceleadingNode_avoidParallels_get, _CsoundAC.VoiceleadingNode_avoidParallels_set)
    __swig_setmethods__["divisionsPerOctave"] = _CsoundAC.VoiceleadingNode_divisionsPerOctave_set
    __swig_getmethods__["divisionsPerOctave"] = _CsoundAC.VoiceleadingNode_divisionsPerOctave_get
    if _newclass:
        divisionsPerOctave = _swig_property(_CsoundAC.VoiceleadingNode_divisionsPerOctave_get, _CsoundAC.VoiceleadingNode_divisionsPerOctave_set)

    def __init__(self):
        """__init__(csound::VoiceleadingNode self) -> VoiceleadingNode"""
        this = _CsoundAC.new_VoiceleadingNode()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_VoiceleadingNode
    __del__ = lambda self: None

    def apply(self, score, priorOperation, currentOperation):
        """apply(VoiceleadingNode self, Score score, VoiceleadingOperation priorOperation, VoiceleadingOperation currentOperation)"""
        return _CsoundAC.VoiceleadingNode_apply(self, score, priorOperation, currentOperation)


    def produceOrTransform(self, collectingNode, beginAt, endAt, coordinates):
        """produceOrTransform(VoiceleadingNode self, Score collectingNode, size_t beginAt, size_t endAt, Eigen::MatrixXd const & coordinates)"""
        return _CsoundAC.VoiceleadingNode_produceOrTransform(self, collectingNode, beginAt, endAt, coordinates)


    def PT(self, time, P_, T):
        """PT(VoiceleadingNode self, double time, double P_, double T)"""
        return _CsoundAC.VoiceleadingNode_PT(self, time, P_, T)


    def PTV(self, time, P_, T, V_):
        """PTV(VoiceleadingNode self, double time, double P_, double T, double V_)"""
        return _CsoundAC.VoiceleadingNode_PTV(self, time, P_, T, V_)


    def PTL(self, time, P_, T, avoidParallels=True):
        """
        PTL(VoiceleadingNode self, double time, double P_, double T, bool avoidParallels=True)
        PTL(VoiceleadingNode self, double time, double P_, double T)
        """
        return _CsoundAC.VoiceleadingNode_PTL(self, time, P_, T, avoidParallels)


    def C(self, *args):
        """
        C(VoiceleadingNode self, double time, double C_)
        C(VoiceleadingNode self, double time, std::string C_)
        """
        return _CsoundAC.VoiceleadingNode_C(self, *args)


    def CV(self, *args):
        """
        CV(VoiceleadingNode self, double time, double C_, double V_)
        CV(VoiceleadingNode self, double time, std::string C_, double V_)
        """
        return _CsoundAC.VoiceleadingNode_CV(self, *args)


    def CL(self, *args):
        """
        CL(VoiceleadingNode self, double time, double C_, bool avoidParallels=True)
        CL(VoiceleadingNode self, double time, double C_)
        CL(VoiceleadingNode self, double time, std::string C_, bool avoidParallels=True)
        CL(VoiceleadingNode self, double time, std::string C_)
        """
        return _CsoundAC.VoiceleadingNode_CL(self, *args)


    def K(self, time):
        """K(VoiceleadingNode self, double time)"""
        return _CsoundAC.VoiceleadingNode_K(self, time)


    def KV(self, time, V_):
        """KV(VoiceleadingNode self, double time, double V_)"""
        return _CsoundAC.VoiceleadingNode_KV(self, time, V_)


    def KL(self, time, avoidParallels=True):
        """
        KL(VoiceleadingNode self, double time, bool avoidParallels=True)
        KL(VoiceleadingNode self, double time)
        """
        return _CsoundAC.VoiceleadingNode_KL(self, time, avoidParallels)


    def Q(self, time, Q_):
        """Q(VoiceleadingNode self, double time, double Q_)"""
        return _CsoundAC.VoiceleadingNode_Q(self, time, Q_)


    def QV(self, time, Q_, V_):
        """QV(VoiceleadingNode self, double time, double Q_, double V_)"""
        return _CsoundAC.VoiceleadingNode_QV(self, time, Q_, V_)


    def QL(self, time, Q_, avoidParallels=True):
        """
        QL(VoiceleadingNode self, double time, double Q_, bool avoidParallels=True)
        QL(VoiceleadingNode self, double time, double Q_)
        """
        return _CsoundAC.VoiceleadingNode_QL(self, time, Q_, avoidParallels)


    def V(self, time, V_):
        """V(VoiceleadingNode self, double time, double V_)"""
        return _CsoundAC.VoiceleadingNode_V(self, time, V_)


    def L(self, time, avoidParallels=True):
        """
        L(VoiceleadingNode self, double time, bool avoidParallels=True)
        L(VoiceleadingNode self, double time)
        """
        return _CsoundAC.VoiceleadingNode_L(self, time, avoidParallels)


    def transform(self, score, rescaleTime=False):
        """
        transform(VoiceleadingNode self, Score score, bool rescaleTime=False)
        transform(VoiceleadingNode self, Score score)
        """
        return _CsoundAC.VoiceleadingNode_transform(self, score, rescaleTime)


    def setModality(self, pcs):
        """setModality(VoiceleadingNode self, DoubleVector pcs)"""
        return _CsoundAC.VoiceleadingNode_setModality(self, pcs)


    def getModality(self):
        """getModality(VoiceleadingNode self) -> DoubleVector"""
        return _CsoundAC.VoiceleadingNode_getModality(self)

VoiceleadingNode_swigregister = _CsoundAC.VoiceleadingNode_swigregister
VoiceleadingNode_swigregister(VoiceleadingNode)

class StringMap(_object):
    """Proxy of C++ std::map<(std::string,std::string)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringMap self) -> SwigPyIterator"""
        return _CsoundAC.StringMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(StringMap self) -> bool"""
        return _CsoundAC.StringMap___nonzero__(self)


    def __bool__(self):
        """__bool__(StringMap self) -> bool"""
        return _CsoundAC.StringMap___bool__(self)


    def __len__(self):
        """__len__(StringMap self) -> std::map< std::string,std::string >::size_type"""
        return _CsoundAC.StringMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(StringMap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _CsoundAC.StringMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(StringMap self, std::map< std::string,std::string >::key_type const & key)"""
        return _CsoundAC.StringMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(StringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _CsoundAC.StringMap_has_key(self, key)


    def keys(self):
        """keys(StringMap self) -> PyObject *"""
        return _CsoundAC.StringMap_keys(self)


    def values(self):
        """values(StringMap self) -> PyObject *"""
        return _CsoundAC.StringMap_values(self)


    def items(self):
        """items(StringMap self) -> PyObject *"""
        return _CsoundAC.StringMap_items(self)


    def __contains__(self, key):
        """__contains__(StringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _CsoundAC.StringMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(StringMap self) -> SwigPyIterator"""
        return _CsoundAC.StringMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(StringMap self) -> SwigPyIterator"""
        return _CsoundAC.StringMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(StringMap self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(StringMap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _CsoundAC.StringMap___setitem__(self, *args)


    def asdict(self):
        """asdict(StringMap self) -> PyObject *"""
        return _CsoundAC.StringMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,std::string)> self, std::less< std::string > const & arg2) -> StringMap
        __init__(std::map<(std::string,std::string)> self) -> StringMap
        __init__(std::map<(std::string,std::string)> self, StringMap arg2) -> StringMap
        """
        this = _CsoundAC.new_StringMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(StringMap self) -> bool"""
        return _CsoundAC.StringMap_empty(self)


    def size(self):
        """size(StringMap self) -> std::map< std::string,std::string >::size_type"""
        return _CsoundAC.StringMap_size(self)


    def swap(self, v):
        """swap(StringMap self, StringMap v)"""
        return _CsoundAC.StringMap_swap(self, v)


    def begin(self):
        """begin(StringMap self) -> std::map< std::string,std::string >::iterator"""
        return _CsoundAC.StringMap_begin(self)


    def end(self):
        """end(StringMap self) -> std::map< std::string,std::string >::iterator"""
        return _CsoundAC.StringMap_end(self)


    def rbegin(self):
        """rbegin(StringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _CsoundAC.StringMap_rbegin(self)


    def rend(self):
        """rend(StringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _CsoundAC.StringMap_rend(self)


    def clear(self):
        """clear(StringMap self)"""
        return _CsoundAC.StringMap_clear(self)


    def get_allocator(self):
        """get_allocator(StringMap self) -> std::map< std::string,std::string >::allocator_type"""
        return _CsoundAC.StringMap_get_allocator(self)


    def count(self, x):
        """count(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _CsoundAC.StringMap_count(self, x)


    def erase(self, *args):
        """
        erase(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(StringMap self, std::map< std::string,std::string >::iterator position)
        erase(StringMap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _CsoundAC.StringMap_erase(self, *args)


    def find(self, x):
        """find(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _CsoundAC.StringMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _CsoundAC.StringMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _CsoundAC.StringMap_upper_bound(self, x)

    __swig_destroy__ = _CsoundAC.delete_StringMap
    __del__ = lambda self: None
StringMap_swigregister = _CsoundAC.StringMap_swigregister
StringMap_swigregister(StringMap)


def printChord(stream, label, chord):
    """printChord(std::ostream & stream, std::string label, DoubleVector chord)"""
    return _CsoundAC.printChord(stream, label, chord)
class Turtle(_object):
    """Proxy of C++ csound::Turtle class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Turtle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Turtle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["note"] = _CsoundAC.Turtle_note_set
    __swig_getmethods__["note"] = _CsoundAC.Turtle_note_get
    if _newclass:
        note = _swig_property(_CsoundAC.Turtle_note_get, _CsoundAC.Turtle_note_set)
    __swig_setmethods__["step"] = _CsoundAC.Turtle_step_set
    __swig_getmethods__["step"] = _CsoundAC.Turtle_step_get
    if _newclass:
        step = _swig_property(_CsoundAC.Turtle_step_get, _CsoundAC.Turtle_step_set)
    __swig_setmethods__["orientation"] = _CsoundAC.Turtle_orientation_set
    __swig_getmethods__["orientation"] = _CsoundAC.Turtle_orientation_get
    if _newclass:
        orientation = _swig_property(_CsoundAC.Turtle_orientation_get, _CsoundAC.Turtle_orientation_set)
    __swig_setmethods__["chord"] = _CsoundAC.Turtle_chord_set
    __swig_getmethods__["chord"] = _CsoundAC.Turtle_chord_get
    if _newclass:
        chord = _swig_property(_CsoundAC.Turtle_chord_get, _CsoundAC.Turtle_chord_set)
    __swig_setmethods__["rangeBass"] = _CsoundAC.Turtle_rangeBass_set
    __swig_getmethods__["rangeBass"] = _CsoundAC.Turtle_rangeBass_get
    if _newclass:
        rangeBass = _swig_property(_CsoundAC.Turtle_rangeBass_get, _CsoundAC.Turtle_rangeBass_set)
    __swig_setmethods__["rangeSize"] = _CsoundAC.Turtle_rangeSize_set
    __swig_getmethods__["rangeSize"] = _CsoundAC.Turtle_rangeSize_get
    if _newclass:
        rangeSize = _swig_property(_CsoundAC.Turtle_rangeSize_get, _CsoundAC.Turtle_rangeSize_set)
    __swig_setmethods__["voicing"] = _CsoundAC.Turtle_voicing_set
    __swig_getmethods__["voicing"] = _CsoundAC.Turtle_voicing_get
    if _newclass:
        voicing = _swig_property(_CsoundAC.Turtle_voicing_get, _CsoundAC.Turtle_voicing_set)
    __swig_setmethods__["modality"] = _CsoundAC.Turtle_modality_set
    __swig_getmethods__["modality"] = _CsoundAC.Turtle_modality_get
    if _newclass:
        modality = _swig_property(_CsoundAC.Turtle_modality_get, _CsoundAC.Turtle_modality_set)

    def __init__(self, *args):
        """
        __init__(csound::Turtle self) -> Turtle
        __init__(csound::Turtle self, Turtle other) -> Turtle
        """
        this = _CsoundAC.new_Turtle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def initialize(self):
        """initialize(Turtle self)"""
        return _CsoundAC.Turtle_initialize(self)


    def __lt__(self, other):
        """__lt__(Turtle self, Turtle other) -> bool"""
        return _CsoundAC.Turtle___lt__(self, other)


    def __str__(self):
        """__str__(Turtle self) -> std::string"""
        return _CsoundAC.Turtle___str__(self)

    __swig_destroy__ = _CsoundAC.delete_Turtle
    __del__ = lambda self: None
Turtle_swigregister = _CsoundAC.Turtle_swigregister
Turtle_swigregister(Turtle)

class Command(_object):
    """Proxy of C++ csound::Command class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Command, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Command, name)
    __repr__ = _swig_repr
    __swig_setmethods__["operation"] = _CsoundAC.Command_operation_set
    __swig_getmethods__["operation"] = _CsoundAC.Command_operation_get
    if _newclass:
        operation = _swig_property(_CsoundAC.Command_operation_get, _CsoundAC.Command_operation_set)
    __swig_setmethods__["target"] = _CsoundAC.Command_target_set
    __swig_getmethods__["target"] = _CsoundAC.Command_target_get
    if _newclass:
        target = _swig_property(_CsoundAC.Command_target_get, _CsoundAC.Command_target_set)
    __swig_setmethods__["equivalence"] = _CsoundAC.Command_equivalence_set
    __swig_getmethods__["equivalence"] = _CsoundAC.Command_equivalence_get
    if _newclass:
        equivalence = _swig_property(_CsoundAC.Command_equivalence_get, _CsoundAC.Command_equivalence_set)
    __swig_setmethods__["dimension"] = _CsoundAC.Command_dimension_set
    __swig_getmethods__["dimension"] = _CsoundAC.Command_dimension_get
    if _newclass:
        dimension = _swig_property(_CsoundAC.Command_dimension_get, _CsoundAC.Command_dimension_set)
    __swig_setmethods__["x"] = _CsoundAC.Command_x_set
    __swig_getmethods__["x"] = _CsoundAC.Command_x_get
    if _newclass:
        x = _swig_property(_CsoundAC.Command_x_get, _CsoundAC.Command_x_set)
    __swig_setmethods__["v"] = _CsoundAC.Command_v_set
    __swig_getmethods__["v"] = _CsoundAC.Command_v_get
    if _newclass:
        v = _swig_property(_CsoundAC.Command_v_get, _CsoundAC.Command_v_set)

    def __init__(self):
        """__init__(csound::Command self) -> Command"""
        this = _CsoundAC.new_Command()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Command
    __del__ = lambda self: None
Command_swigregister = _CsoundAC.Command_swigregister
Command_swigregister(Command)

class ChordLindenmayer(VoiceleadingNode):
    """Proxy of C++ csound::ChordLindenmayer class."""

    __swig_setmethods__ = {}
    for _s in [VoiceleadingNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChordLindenmayer, name, value)
    __swig_getmethods__ = {}
    for _s in [VoiceleadingNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChordLindenmayer, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(csound::ChordLindenmayer self) -> ChordLindenmayer"""
        this = _CsoundAC.new_ChordLindenmayer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ChordLindenmayer
    __del__ = lambda self: None

    def getIterationCount(self):
        """getIterationCount(ChordLindenmayer self) -> int"""
        return _CsoundAC.ChordLindenmayer_getIterationCount(self)


    def setIterationCount(self, count):
        """setIterationCount(ChordLindenmayer self, int count)"""
        return _CsoundAC.ChordLindenmayer_setIterationCount(self, count)


    def getAngle(self):
        """getAngle(ChordLindenmayer self) -> double"""
        return _CsoundAC.ChordLindenmayer_getAngle(self)


    def setAngle(self, angle):
        """setAngle(ChordLindenmayer self, double angle)"""
        return _CsoundAC.ChordLindenmayer_setAngle(self, angle)


    def getAxiom(self):
        """getAxiom(ChordLindenmayer self) -> std::string"""
        return _CsoundAC.ChordLindenmayer_getAxiom(self)


    def setAxiom(self, axiom):
        """setAxiom(ChordLindenmayer self, std::string axiom)"""
        return _CsoundAC.ChordLindenmayer_setAxiom(self, axiom)


    def addRule(self, command, replacement):
        """addRule(ChordLindenmayer self, std::string command, std::string replacement)"""
        return _CsoundAC.ChordLindenmayer_addRule(self, command, replacement)


    def getReplacement(self, command):
        """getReplacement(ChordLindenmayer self, std::string command) -> std::string"""
        return _CsoundAC.ChordLindenmayer_getReplacement(self, command)


    def generate(self):
        """generate(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_generate(self)


    def clear(self):
        """clear(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_clear(self)

    __swig_setmethods__["score"] = _CsoundAC.ChordLindenmayer_score_set
    __swig_getmethods__["score"] = _CsoundAC.ChordLindenmayer_score_get
    if _newclass:
        score = _swig_property(_CsoundAC.ChordLindenmayer_score_get, _CsoundAC.ChordLindenmayer_score_set)
    __swig_setmethods__["iterationCount"] = _CsoundAC.ChordLindenmayer_iterationCount_set
    __swig_getmethods__["iterationCount"] = _CsoundAC.ChordLindenmayer_iterationCount_get
    if _newclass:
        iterationCount = _swig_property(_CsoundAC.ChordLindenmayer_iterationCount_get, _CsoundAC.ChordLindenmayer_iterationCount_set)
    __swig_setmethods__["angle"] = _CsoundAC.ChordLindenmayer_angle_set
    __swig_getmethods__["angle"] = _CsoundAC.ChordLindenmayer_angle_get
    if _newclass:
        angle = _swig_property(_CsoundAC.ChordLindenmayer_angle_get, _CsoundAC.ChordLindenmayer_angle_set)
    __swig_setmethods__["axiom"] = _CsoundAC.ChordLindenmayer_axiom_set
    __swig_getmethods__["axiom"] = _CsoundAC.ChordLindenmayer_axiom_get
    if _newclass:
        axiom = _swig_property(_CsoundAC.ChordLindenmayer_axiom_get, _CsoundAC.ChordLindenmayer_axiom_set)
    __swig_setmethods__["production"] = _CsoundAC.ChordLindenmayer_production_set
    __swig_getmethods__["production"] = _CsoundAC.ChordLindenmayer_production_get
    if _newclass:
        production = _swig_property(_CsoundAC.ChordLindenmayer_production_get, _CsoundAC.ChordLindenmayer_production_set)
    __swig_setmethods__["turtle"] = _CsoundAC.ChordLindenmayer_turtle_set
    __swig_getmethods__["turtle"] = _CsoundAC.ChordLindenmayer_turtle_get
    if _newclass:
        turtle = _swig_property(_CsoundAC.ChordLindenmayer_turtle_get, _CsoundAC.ChordLindenmayer_turtle_set)
    __swig_setmethods__["rules"] = _CsoundAC.ChordLindenmayer_rules_set
    __swig_getmethods__["rules"] = _CsoundAC.ChordLindenmayer_rules_get
    if _newclass:
        rules = _swig_property(_CsoundAC.ChordLindenmayer_rules_get, _CsoundAC.ChordLindenmayer_rules_set)
    __swig_setmethods__["turtleStack"] = _CsoundAC.ChordLindenmayer_turtleStack_set
    __swig_getmethods__["turtleStack"] = _CsoundAC.ChordLindenmayer_turtleStack_get
    if _newclass:
        turtleStack = _swig_property(_CsoundAC.ChordLindenmayer_turtleStack_get, _CsoundAC.ChordLindenmayer_turtleStack_set)
    __swig_setmethods__["beganAt"] = _CsoundAC.ChordLindenmayer_beganAt_set
    __swig_getmethods__["beganAt"] = _CsoundAC.ChordLindenmayer_beganAt_get
    if _newclass:
        beganAt = _swig_property(_CsoundAC.ChordLindenmayer_beganAt_get, _CsoundAC.ChordLindenmayer_beganAt_set)
    __swig_setmethods__["endedAt"] = _CsoundAC.ChordLindenmayer_endedAt_set
    __swig_getmethods__["endedAt"] = _CsoundAC.ChordLindenmayer_endedAt_get
    if _newclass:
        endedAt = _swig_property(_CsoundAC.ChordLindenmayer_endedAt_get, _CsoundAC.ChordLindenmayer_endedAt_set)
    __swig_setmethods__["elapsed"] = _CsoundAC.ChordLindenmayer_elapsed_set
    __swig_getmethods__["elapsed"] = _CsoundAC.ChordLindenmayer_elapsed_get
    if _newclass:
        elapsed = _swig_property(_CsoundAC.ChordLindenmayer_elapsed_get, _CsoundAC.ChordLindenmayer_elapsed_set)

    def initialize(self):
        """initialize(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_initialize(self)


    def generateLindenmayerSystem(self):
        """generateLindenmayerSystem(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_generateLindenmayerSystem(self)


    def writeScore(self):
        """writeScore(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_writeScore(self)


    def fixStatus(self):
        """fixStatus(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_fixStatus(self)


    def tieOverlappingNotes(self):
        """tieOverlappingNotes(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_tieOverlappingNotes(self)


    def applyVoiceleadingOperations(self):
        """applyVoiceleadingOperations(ChordLindenmayer self)"""
        return _CsoundAC.ChordLindenmayer_applyVoiceleadingOperations(self)


    def interpret(self, command):
        """interpret(ChordLindenmayer self, std::string command)"""
        return _CsoundAC.ChordLindenmayer_interpret(self, command)


    def getDimension(self, dimension):
        """getDimension(ChordLindenmayer self, char dimension) -> int"""
        return _CsoundAC.ChordLindenmayer_getDimension(self, dimension)


    def parseCommand(self, command, operation, target, equivalenceClass, dimension, dimension1, scalar, vector):
        """parseCommand(ChordLindenmayer self, std::string const & command, std::string & operation, char & target, char & equivalenceClass, size_t & dimension, size_t & dimension1, double & scalar, DoubleVector vector) -> char"""
        return _CsoundAC.ChordLindenmayer_parseCommand(self, command, operation, target, equivalenceClass, dimension, dimension1, scalar, vector)


    def createRotation(self, dimension1, dimension2, angle):
        """createRotation(ChordLindenmayer self, int dimension1, int dimension2, double angle) -> Eigen::MatrixXd"""
        return _CsoundAC.ChordLindenmayer_createRotation(self, dimension1, dimension2, angle)


    def equivalence(self, value, equivalenceClass):
        """equivalence(ChordLindenmayer self, double & value, char equivalenceClass) -> double"""
        return _CsoundAC.ChordLindenmayer_equivalence(self, value, equivalenceClass)


    def produceOrTransform(self, score, beginAt, endAt, compositeCordinates):
        """produceOrTransform(ChordLindenmayer self, Score score, size_t beginAt, size_t endAt, Eigen::MatrixXd const & compositeCordinates)"""
        return _CsoundAC.ChordLindenmayer_produceOrTransform(self, score, beginAt, endAt, compositeCordinates)

ChordLindenmayer_swigregister = _CsoundAC.ChordLindenmayer_swigregister
ChordLindenmayer_swigregister(ChordLindenmayer)


def _print(format):
    """_print(char const * format)"""
    return _CsoundAC._print(format)

def factorial(n):
    """factorial(double n) -> double"""
    return _CsoundAC.factorial(n)

def EPSILON():
    """EPSILON() -> double"""
    return _CsoundAC.EPSILON()

def epsilonFactor():
    """epsilonFactor() -> double &"""
    return _CsoundAC.epsilonFactor()

def eq_epsilon(a, b):
    """eq_epsilon(double a, double b) -> bool"""
    return _CsoundAC.eq_epsilon(a, b)

def gt_epsilon(a, b):
    """gt_epsilon(double a, double b) -> double"""
    return _CsoundAC.gt_epsilon(a, b)

def lt_epsilon(a, b):
    """lt_epsilon(double a, double b) -> double"""
    return _CsoundAC.lt_epsilon(a, b)

def ge_epsilon(a, b):
    """ge_epsilon(double a, double b) -> double"""
    return _CsoundAC.ge_epsilon(a, b)

def le_epsilon(a, b):
    """le_epsilon(double a, double b) -> double"""
    return _CsoundAC.le_epsilon(a, b)

def OCTAVE():
    """OCTAVE() -> double"""
    return _CsoundAC.OCTAVE()

def MIDDLE_C():
    """MIDDLE_C() -> double"""
    return _CsoundAC.MIDDLE_C()

def C4():
    """C4() -> double"""
    return _CsoundAC.C4()

def T(pitch, semitones):
    """T(double pitch, double semitones) -> double"""
    return _CsoundAC.T(pitch, semitones)

def I(pitch, center=0.0):
    """
    I(double pitch, double center=0.0) -> double
    I(double pitch) -> double
    """
    return _CsoundAC.I(pitch, center)

def modulo(dividend, divisor):
    """modulo(double dividend, double divisor) -> double"""
    return _CsoundAC.modulo(dividend, divisor)

def epc(pitch):
    """epc(double pitch) -> double"""
    return _CsoundAC.epc(pitch)
EQUIVALENCE_RELATION_r = _CsoundAC.EQUIVALENCE_RELATION_r
EQUIVALENCE_RELATION_R = _CsoundAC.EQUIVALENCE_RELATION_R
EQUIVALENCE_RELATION_P = _CsoundAC.EQUIVALENCE_RELATION_P
EQUIVALENCE_RELATION_T = _CsoundAC.EQUIVALENCE_RELATION_T
EQUIVALENCE_RELATION_Tg = _CsoundAC.EQUIVALENCE_RELATION_Tg
EQUIVALENCE_RELATION_I = _CsoundAC.EQUIVALENCE_RELATION_I
EQUIVALENCE_RELATION_V = _CsoundAC.EQUIVALENCE_RELATION_V
EQUIVALENCE_RELATION_RP = _CsoundAC.EQUIVALENCE_RELATION_RP
EQUIVALENCE_RELATION_RT = _CsoundAC.EQUIVALENCE_RELATION_RT
EQUIVALENCE_RELATION_RTg = _CsoundAC.EQUIVALENCE_RELATION_RTg
EQUIVALENCE_RELATION_RI = _CsoundAC.EQUIVALENCE_RELATION_RI
EQUIVALENCE_RELATION_PT = _CsoundAC.EQUIVALENCE_RELATION_PT
EQUIVALENCE_RELATION_PTg = _CsoundAC.EQUIVALENCE_RELATION_PTg
EQUIVALENCE_RELATION_PI = _CsoundAC.EQUIVALENCE_RELATION_PI
EQUIVALENCE_RELATION_TI = _CsoundAC.EQUIVALENCE_RELATION_TI
EQUIVALENCE_RELATION_RPT = _CsoundAC.EQUIVALENCE_RELATION_RPT
EQUIVALENCE_RELATION_RPTg = _CsoundAC.EQUIVALENCE_RELATION_RPTg
EQUIVALENCE_RELATION_RPI = _CsoundAC.EQUIVALENCE_RELATION_RPI
EQUIVALENCE_RELATION_RTI = _CsoundAC.EQUIVALENCE_RELATION_RTI
EQUIVALENCE_RELATION_RTgI = _CsoundAC.EQUIVALENCE_RELATION_RTgI
EQUIVALENCE_RELATION_RPTI = _CsoundAC.EQUIVALENCE_RELATION_RPTI
EQUIVALENCE_RELATION_RPTgI = _CsoundAC.EQUIVALENCE_RELATION_RPTgI

def pitchClassForName(pitchclass):
    """pitchClassForName(std::string pitchclass) -> double"""
    return _CsoundAC.pitchClassForName(pitchclass)

def nameForChord(chord):
    """nameForChord(Chord chord) -> std::string"""
    return _CsoundAC.nameForChord(chord)

def chordForName(name):
    """chordForName(std::string name) -> Chord"""
    return _CsoundAC.chordForName(name)

def split(arg1):
    """split(std::string arg1) -> std::vector< std::string,std::allocator< std::string > >"""
    return _CsoundAC.split(arg1)

def iterator(voiceN, first):
    """iterator(int voiceN, double first) -> Chord"""
    return _CsoundAC.iterator(voiceN, first)

def next(odometer, low, high, g=1.0):
    """
    next(Chord odometer, Chord low, double high, double g=1.0) -> bool
    next(Chord odometer, Chord low, double high) -> bool
    """
    return _CsoundAC.next(odometer, low, high, g)

def __eq__(a, b):
    """__eq__(Chord a, Chord b) -> bool"""
    return _CsoundAC.__eq__(a, b)

def __lt__(*args):
    """
    __lt__(Event a, Event b) -> bool
    __lt__(Chord a, Chord b) -> bool
    """
    return _CsoundAC.__lt__(*args)

def __le__(a, b):
    """__le__(Chord a, Chord b) -> bool"""
    return _CsoundAC.__le__(a, b)

def __gt__(a, b):
    """__gt__(Chord a, Chord b) -> bool"""
    return _CsoundAC.__gt__(a, b)

def __ge__(a, b):
    """__ge__(Chord a, Chord b) -> bool"""
    return _CsoundAC.__ge__(a, b)
class Chord(_object):
    """Proxy of C++ csound::Chord class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chord, name)
    __repr__ = _swig_repr
    PITCH = _CsoundAC.Chord_PITCH
    DURATION = _CsoundAC.Chord_DURATION
    LOUDNESS = _CsoundAC.Chord_LOUDNESS
    INSTRUMENT = _CsoundAC.Chord_INSTRUMENT
    PAN = _CsoundAC.Chord_PAN
    COUNT = _CsoundAC.Chord_COUNT

    def __init__(self, *args):
        """
        __init__(csound::Chord self) -> Chord
        __init__(csound::Chord self, Chord other) -> Chord
        """
        this = _CsoundAC.new_Chord(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_Chord
    __del__ = lambda self: None

    def voices(self):
        """voices(Chord self) -> size_t"""
        return _CsoundAC.Chord_voices(self)


    def resize(self, voiceN):
        """resize(Chord self, size_t voiceN)"""
        return _CsoundAC.Chord_resize(self, voiceN)


    def toString(self):
        """toString(Chord self) -> std::string"""
        return _CsoundAC.Chord_toString(self)


    def fromString(self, text):
        """fromString(Chord self, std::string text)"""
        return _CsoundAC.Chord_fromString(self, text)


    def getPitch(self, voice):
        """getPitch(Chord self, int voice) -> double"""
        return _CsoundAC.Chord_getPitch(self, voice)


    def setPitch(self, voice, value):
        """setPitch(Chord self, int voice, double value)"""
        return _CsoundAC.Chord_setPitch(self, voice, value)


    def getDuration(self, voice=0):
        """
        getDuration(Chord self, int voice=0) -> double
        getDuration(Chord self) -> double
        """
        return _CsoundAC.Chord_getDuration(self, voice)


    def setDuration(self, value, voice=-1):
        """
        setDuration(Chord self, double value, int voice=-1)
        setDuration(Chord self, double value)
        """
        return _CsoundAC.Chord_setDuration(self, value, voice)


    def getLoudness(self, voice=0):
        """
        getLoudness(Chord self, int voice=0) -> double
        getLoudness(Chord self) -> double
        """
        return _CsoundAC.Chord_getLoudness(self, voice)


    def setLoudness(self, value, voice=-1):
        """
        setLoudness(Chord self, double value, int voice=-1)
        setLoudness(Chord self, double value)
        """
        return _CsoundAC.Chord_setLoudness(self, value, voice)


    def getInstrument(self, voice=0):
        """
        getInstrument(Chord self, int voice=0) -> double
        getInstrument(Chord self) -> double
        """
        return _CsoundAC.Chord_getInstrument(self, voice)


    def setInstrument(self, value, voice=-1):
        """
        setInstrument(Chord self, double value, int voice=-1)
        setInstrument(Chord self, double value)
        """
        return _CsoundAC.Chord_setInstrument(self, value, voice)


    def getPan(self, voice=0):
        """
        getPan(Chord self, int voice=0) -> double
        getPan(Chord self) -> double
        """
        return _CsoundAC.Chord_getPan(self, voice)


    def setPan(self, value, voice=-1):
        """
        setPan(Chord self, double value, int voice=-1)
        setPan(Chord self, double value)
        """
        return _CsoundAC.Chord_setPan(self, value, voice)


    def count(self, pitch):
        """count(Chord self, double pitch) -> size_t"""
        return _CsoundAC.Chord_count(self, pitch)


    def contains(self, pitch_):
        """contains(Chord self, double pitch_) -> bool"""
        return _CsoundAC.Chord_contains(self, pitch_)


    def min(self):
        """min(Chord self) -> DoubleVector"""
        return _CsoundAC.Chord_min(self)


    def max(self):
        """max(Chord self) -> DoubleVector"""
        return _CsoundAC.Chord_max(self)


    def minimumInterval(self):
        """minimumInterval(Chord self) -> double"""
        return _CsoundAC.Chord_minimumInterval(self)


    def maximumInterval(self):
        """maximumInterval(Chord self) -> double"""
        return _CsoundAC.Chord_maximumInterval(self)


    def floor(self):
        """floor(Chord self) -> Chord"""
        return _CsoundAC.Chord_floor(self)


    def ceiling(self):
        """ceiling(Chord self) -> Chord"""
        return _CsoundAC.Chord_ceiling(self)


    def origin(self):
        """origin(Chord self) -> Chord"""
        return _CsoundAC.Chord_origin(self)


    def distanceToOrigin(self):
        """distanceToOrigin(Chord self) -> double"""
        return _CsoundAC.Chord_distanceToOrigin(self)


    def layer(self):
        """layer(Chord self) -> double"""
        return _CsoundAC.Chord_layer(self)


    def distanceToUnisonDiagonal(self):
        """distanceToUnisonDiagonal(Chord self) -> double"""
        return _CsoundAC.Chord_distanceToUnisonDiagonal(self)


    def maximallyEven(self):
        """maximallyEven(Chord self) -> Chord"""
        return _CsoundAC.Chord_maximallyEven(self)


    def T(self, interval):
        """T(Chord self, double interval) -> Chord"""
        return _CsoundAC.Chord_T(self, interval)


    def I(self, center=0.0):
        """
        I(Chord self, double center=0.0) -> Chord
        I(Chord self) -> Chord
        """
        return _CsoundAC.Chord_I(self, center)


    def cycle(self, stride=1):
        """
        cycle(Chord self, int stride=1) -> Chord
        cycle(Chord self) -> Chord
        """
        return _CsoundAC.Chord_cycle(self, stride)


    def permutations(self):
        """permutations(Chord self) -> std::vector< csound::Chord,std::allocator< csound::Chord > >"""
        return _CsoundAC.Chord_permutations(self)


    def v(self, direction=1):
        """
        v(Chord self, int direction=1) -> Chord
        v(Chord self) -> Chord
        """
        return _CsoundAC.Chord_v(self, direction)


    def voicings(self):
        """voicings(Chord self) -> std::vector< csound::Chord,std::allocator< csound::Chord > >"""
        return _CsoundAC.Chord_voicings(self)


    def isepcs(self):
        """isepcs(Chord self) -> bool"""
        return _CsoundAC.Chord_isepcs(self)


    def epcs(self):
        """epcs(Chord self) -> Chord"""
        return _CsoundAC.Chord_epcs(self)


    def iset(self):
        """iset(Chord self) -> bool"""
        return _CsoundAC.Chord_iset(self)


    def et(self):
        """et(Chord self) -> Chord"""
        return _CsoundAC.Chord_et(self)


    def iseR(self, range_):
        """iseR(Chord self, double range_) -> bool"""
        return _CsoundAC.Chord_iseR(self, range_)


    def iseO(self):
        """iseO(Chord self) -> bool"""
        return _CsoundAC.Chord_iseO(self)


    def eR(self, range):
        """eR(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eR(self, range)


    def eO(self):
        """eO(Chord self) -> Chord"""
        return _CsoundAC.Chord_eO(self)


    def iseP(self):
        """iseP(Chord self) -> bool"""
        return _CsoundAC.Chord_iseP(self)


    def eP(self):
        """eP(Chord self) -> Chord"""
        return _CsoundAC.Chord_eP(self)


    def iseT(self):
        """iseT(Chord self) -> bool"""
        return _CsoundAC.Chord_iseT(self)


    def eT(self):
        """eT(Chord self) -> Chord"""
        return _CsoundAC.Chord_eT(self)


    def eTT(self, g=1.0):
        """
        eTT(Chord self, double g=1.0) -> Chord
        eTT(Chord self) -> Chord
        """
        return _CsoundAC.Chord_eTT(self, g)


    def iseTT(self, g=1.0):
        """
        iseTT(Chord self, double g=1.0) -> bool
        iseTT(Chord self) -> bool
        """
        return _CsoundAC.Chord_iseTT(self, g)


    def iseI(self, *args):
        """
        iseI(Chord self, Chord inverse) -> bool
        iseI(Chord self) -> bool
        """
        return _CsoundAC.Chord_iseI(self, *args)


    def eI(self):
        """eI(Chord self) -> Chord"""
        return _CsoundAC.Chord_eI(self)


    def iseRP(self, range):
        """iseRP(Chord self, double range) -> bool"""
        return _CsoundAC.Chord_iseRP(self, range)


    def iseOP(self):
        """iseOP(Chord self) -> bool"""
        return _CsoundAC.Chord_iseOP(self)


    def eRP(self, range):
        """eRP(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eRP(self, range)


    def eOP(self):
        """eOP(Chord self) -> Chord"""
        return _CsoundAC.Chord_eOP(self)


    def iseV(self):
        """iseV(Chord self) -> bool"""
        return _CsoundAC.Chord_iseV(self)


    def eV(self):
        """eV(Chord self) -> Chord"""
        return _CsoundAC.Chord_eV(self)


    def iseRPT(self, range):
        """iseRPT(Chord self, double range) -> bool"""
        return _CsoundAC.Chord_iseRPT(self, range)


    def iseRPTT(self, range, g=1.0):
        """
        iseRPTT(Chord self, double range, double g=1.0) -> bool
        iseRPTT(Chord self, double range) -> bool
        """
        return _CsoundAC.Chord_iseRPTT(self, range, g)


    def iseOPT(self):
        """iseOPT(Chord self) -> bool"""
        return _CsoundAC.Chord_iseOPT(self)


    def iseOPTT(self, g=1.0):
        """
        iseOPTT(Chord self, double g=1.0) -> bool
        iseOPTT(Chord self) -> bool
        """
        return _CsoundAC.Chord_iseOPTT(self, g)


    def eRPT(self, range):
        """eRPT(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eRPT(self, range)


    def eRPTT(self, range, g=1.0):
        """
        eRPTT(Chord self, double range, double g=1.0) -> Chord
        eRPTT(Chord self, double range) -> Chord
        """
        return _CsoundAC.Chord_eRPTT(self, range, g)


    def eOPT(self):
        """eOPT(Chord self) -> Chord"""
        return _CsoundAC.Chord_eOPT(self)


    def eOPTT(self, g=1.0):
        """
        eOPTT(Chord self, double g=1.0) -> Chord
        eOPTT(Chord self) -> Chord
        """
        return _CsoundAC.Chord_eOPTT(self, g)


    def iseRPI(self, range):
        """iseRPI(Chord self, double range) -> bool"""
        return _CsoundAC.Chord_iseRPI(self, range)


    def iseOPI(self):
        """iseOPI(Chord self) -> bool"""
        return _CsoundAC.Chord_iseOPI(self)


    def eRPI(self, range):
        """eRPI(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eRPI(self, range)


    def eOPI(self):
        """eOPI(Chord self) -> Chord"""
        return _CsoundAC.Chord_eOPI(self)


    def iseRPTI(self, range):
        """iseRPTI(Chord self, double range) -> bool"""
        return _CsoundAC.Chord_iseRPTI(self, range)


    def iseRPTTI(self, range):
        """iseRPTTI(Chord self, double range) -> bool"""
        return _CsoundAC.Chord_iseRPTTI(self, range)


    def iseOPTI(self):
        """iseOPTI(Chord self) -> bool"""
        return _CsoundAC.Chord_iseOPTI(self)


    def iseOPTTI(self):
        """iseOPTTI(Chord self) -> bool"""
        return _CsoundAC.Chord_iseOPTTI(self)


    def eRPTI(self, range):
        """eRPTI(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eRPTI(self, range)


    def eRPTTI(self, range):
        """eRPTTI(Chord self, double range) -> Chord"""
        return _CsoundAC.Chord_eRPTTI(self, range)


    def eOPTI(self):
        """eOPTI(Chord self) -> Chord"""
        return _CsoundAC.Chord_eOPTI(self)


    def eOPTTI(self):
        """eOPTTI(Chord self) -> Chord"""
        return _CsoundAC.Chord_eOPTTI(self)


    def name(self):
        """name(Chord self) -> std::string"""
        return _CsoundAC.Chord_name(self)


    def information(self):
        """information(Chord self) -> std::string"""
        return _CsoundAC.Chord_information(self)


    def move(self, voice, interval):
        """move(Chord self, int voice, double interval) -> Chord"""
        return _CsoundAC.Chord_move(self, voice, interval)


    def nrL(self):
        """nrL(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrL(self)


    def nrP(self):
        """nrP(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrP(self)


    def nrR(self):
        """nrR(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrR(self)


    def nrN(self):
        """nrN(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrN(self)


    def nrS(self):
        """nrS(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrS(self)


    def nrH(self):
        """nrH(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrH(self)


    def nrD(self):
        """nrD(Chord self) -> Chord"""
        return _CsoundAC.Chord_nrD(self)


    def K(self, *args):
        """
        K(Chord self, double range) -> Chord
        K(Chord self) -> Chord
        """
        return _CsoundAC.Chord_K(self, *args)


    def Tform(self, Y, g=1.0):
        """
        Tform(Chord self, Chord Y, double g=1.0) -> bool
        Tform(Chord self, Chord Y) -> bool
        """
        return _CsoundAC.Chord_Tform(self, Y, g)


    def Iform(self, Y, g=1.0):
        """
        Iform(Chord self, Chord Y, double g=1.0) -> bool
        Iform(Chord self, Chord Y) -> bool
        """
        return _CsoundAC.Chord_Iform(self, Y, g)


    def Q(self, x, m, g=1.0):
        """
        Q(Chord self, double x, Chord m, double g=1.0) -> Chord
        Q(Chord self, double x, Chord m) -> Chord
        """
        return _CsoundAC.Chord_Q(self, x, m, g)


    def note(self, *args):
        """
        note(Chord self, int voice, double time_, double duration_, double channel_, double velocity_, double pan_) -> Event
        note(Chord self, int voice, double time_, double duration_, double channel_, double velocity_) -> Event
        note(Chord self, int voice, double time_, double duration_, double channel_) -> Event
        note(Chord self, int voice, double time_, double duration_) -> Event
        note(Chord self, int voice, double time_) -> Event
        """
        return _CsoundAC.Chord_note(self, *args)


    def notes(self, *args):
        """
        notes(Chord self, double time_, double duration_, double channel_, double velocity_, double pan_) -> Score
        notes(Chord self, double time_, double duration_, double channel_, double velocity_) -> Score
        notes(Chord self, double time_, double duration_, double channel_) -> Score
        notes(Chord self, double time_, double duration_) -> Score
        notes(Chord self, double time_) -> Score
        """
        return _CsoundAC.Chord_notes(self, *args)


    def toScore(self, score, time_, voiceIsInstrument=True):
        """
        toScore(Chord self, Score score, double time_, bool voiceIsInstrument=True)
        toScore(Chord self, Score score, double time_)
        """
        return _CsoundAC.Chord_toScore(self, score, time_, voiceIsInstrument)


    def a(self, arpeggiation, resultPitch, resultVoice):
        """a(Chord self, int arpeggiation, double & resultPitch, int & resultVoice) -> Chord"""
        return _CsoundAC.Chord_a(self, arpeggiation, resultPitch, resultVoice)

Chord_swigregister = _CsoundAC.Chord_swigregister
Chord_swigregister(Chord)


def euclidean(*args):
    """
    euclidean(Chord a, Chord b) -> double
    euclidean(Chord a, Chord b) -> double
    """
    return _CsoundAC.euclidean(*args)

def midpoint(a, b):
    """midpoint(Chord a, Chord b) -> Chord"""
    return _CsoundAC.midpoint(a, b)

def pitchClassesForNames():
    """pitchClassesForNames() -> std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > const &"""
    return _CsoundAC.pitchClassesForNames()

def namesForChords():
    """namesForChords() -> std::map< csound::Chord,std::string,std::less< csound::Chord >,std::allocator< std::pair< csound::Chord const,std::string > > > &"""
    return _CsoundAC.namesForChords()

def chordsForNames():
    """chordsForNames() -> std::map< std::string,csound::Chord,std::less< std::string >,std::allocator< std::pair< std::string const,csound::Chord > > > &"""
    return _CsoundAC.chordsForNames()

def fill(rootName, rootPitch, typeName, typePitches, debug=False):
    """
    fill(std::string rootName, double rootPitch, std::string typeName, std::string typePitches, bool debug=False)
    fill(std::string rootName, double rootPitch, std::string typeName, std::string typePitches)
    """
    return _CsoundAC.fill(rootName, rootPitch, typeName, typePitches, debug)

def initializeNames():
    """initializeNames()"""
    return _CsoundAC.initializeNames()

def allOfEquivalenceClass(voiceN, equivalence, g=1.0):
    """
    allOfEquivalenceClass(int voiceN, std::string equivalence, double g=1.0) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
    allOfEquivalenceClass(int voiceN, std::string equivalence) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
    """
    return _CsoundAC.allOfEquivalenceClass(voiceN, equivalence, g)

def voiceleading(a, b):
    """voiceleading(Chord a, Chord b) -> Chord"""
    return _CsoundAC.voiceleading(a, b)

def parallelFifth(a, b):
    """parallelFifth(Chord a, Chord b) -> bool"""
    return _CsoundAC.parallelFifth(a, b)

def voiceleadingSmoothness(a, b):
    """voiceleadingSmoothness(Chord a, Chord b) -> double"""
    return _CsoundAC.voiceleadingSmoothness(a, b)

def voiceleadingSmoother(*args):
    """
    voiceleadingSmoother(Chord source, Chord d1, Chord d2, bool avoidParallels=False, double range) -> Chord
    voiceleadingSmoother(Chord source, Chord d1, Chord d2, bool avoidParallels=False) -> Chord
    voiceleadingSmoother(Chord source, Chord d1, Chord d2) -> Chord
    """
    return _CsoundAC.voiceleadingSmoother(*args)

def voiceleadingSimpler(source, d1, d2, avoidParallels=False):
    """
    voiceleadingSimpler(Chord source, Chord d1, Chord d2, bool avoidParallels=False) -> Chord
    voiceleadingSimpler(Chord source, Chord d1, Chord d2) -> Chord
    """
    return _CsoundAC.voiceleadingSimpler(source, d1, d2, avoidParallels)

def voiceleadingCloser(source, d1, d2, avoidParallels=False):
    """
    voiceleadingCloser(Chord source, Chord d1, Chord d2, bool avoidParallels=False) -> Chord
    voiceleadingCloser(Chord source, Chord d1, Chord d2) -> Chord
    """
    return _CsoundAC.voiceleadingCloser(source, d1, d2, avoidParallels)

def voiceleadingClosestRange(source, destination, range, avoidParallels=False):
    """
    voiceleadingClosestRange(Chord source, Chord destination, double range, bool avoidParallels=False) -> Chord
    voiceleadingClosestRange(Chord source, Chord destination, double range) -> Chord
    """
    return _CsoundAC.voiceleadingClosestRange(source, destination, range, avoidParallels)

def closestPitch(pitch, chord):
    """closestPitch(double pitch, Chord chord) -> double"""
    return _CsoundAC.closestPitch(pitch, chord)

def conformToPitchClassSet(pitch, pcs):
    """conformToPitchClassSet(double pitch, Chord pcs) -> double"""
    return _CsoundAC.conformToPitchClassSet(pitch, pcs)

def conformToChord(event, chord, octaveEquivalence=True):
    """
    conformToChord(Event event, Chord chord, bool octaveEquivalence=True)
    conformToChord(Event event, Chord chord)
    """
    return _CsoundAC.conformToChord(event, chord, octaveEquivalence)

def insert(score, chord, time_):
    """insert(Score score, Chord chord, double time_)"""
    return _CsoundAC.insert(score, chord, time_)

def slice(score, startTime, endTime):
    """slice(Score score, double startTime, double endTime) -> std::vector< csound::Event *,std::allocator< csound::Event * > >"""
    return _CsoundAC.slice(score, startTime, endTime)

def apply(score, chord, startTime, endTime, octaveEquivalence=True):
    """
    apply(Score score, Chord chord, double startTime, double endTime, bool octaveEquivalence=True)
    apply(Score score, Chord chord, double startTime, double endTime)
    """
    return _CsoundAC.apply(score, chord, startTime, endTime, octaveEquivalence)

def gather(score, startTime, endTime):
    """gather(Score score, double startTime, double endTime) -> Chord"""
    return _CsoundAC.gather(score, startTime, endTime)

def octavewiseRevoicings(*args):
    """
    octavewiseRevoicings(Chord chord, double range) -> int
    octavewiseRevoicings(Chord chord) -> int
    """
    return _CsoundAC.octavewiseRevoicings(*args)

def octavewiseRevoicing(chord, revoicingNumber_, range, debug=False):
    """
    octavewiseRevoicing(Chord chord, int revoicingNumber_, double range, bool debug=False) -> Chord
    octavewiseRevoicing(Chord chord, int revoicingNumber_, double range) -> Chord
    """
    return _CsoundAC.octavewiseRevoicing(chord, revoicingNumber_, range, debug)

def indexForOctavewiseRevoicing(chord, range, debug=False):
    """
    indexForOctavewiseRevoicing(Chord chord, double range, bool debug=False) -> int
    indexForOctavewiseRevoicing(Chord chord, double range) -> int
    """
    return _CsoundAC.indexForOctavewiseRevoicing(chord, range, debug)
class ChordSpaceGroup(_object):
    """Proxy of C++ csound::ChordSpaceGroup class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChordSpaceGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChordSpaceGroup, name)
    __repr__ = _swig_repr
    __swig_setmethods__["N"] = _CsoundAC.ChordSpaceGroup_N_set
    __swig_getmethods__["N"] = _CsoundAC.ChordSpaceGroup_N_get
    if _newclass:
        N = _swig_property(_CsoundAC.ChordSpaceGroup_N_get, _CsoundAC.ChordSpaceGroup_N_set)
    __swig_setmethods__["g"] = _CsoundAC.ChordSpaceGroup_g_set
    __swig_getmethods__["g"] = _CsoundAC.ChordSpaceGroup_g_get
    if _newclass:
        g = _swig_property(_CsoundAC.ChordSpaceGroup_g_get, _CsoundAC.ChordSpaceGroup_g_set)
    __swig_setmethods__["range"] = _CsoundAC.ChordSpaceGroup_range_set
    __swig_getmethods__["range"] = _CsoundAC.ChordSpaceGroup_range_get
    if _newclass:
        range = _swig_property(_CsoundAC.ChordSpaceGroup_range_get, _CsoundAC.ChordSpaceGroup_range_set)
    __swig_setmethods__["countP"] = _CsoundAC.ChordSpaceGroup_countP_set
    __swig_getmethods__["countP"] = _CsoundAC.ChordSpaceGroup_countP_get
    if _newclass:
        countP = _swig_property(_CsoundAC.ChordSpaceGroup_countP_get, _CsoundAC.ChordSpaceGroup_countP_set)
    __swig_setmethods__["countI"] = _CsoundAC.ChordSpaceGroup_countI_set
    __swig_getmethods__["countI"] = _CsoundAC.ChordSpaceGroup_countI_get
    if _newclass:
        countI = _swig_property(_CsoundAC.ChordSpaceGroup_countI_get, _CsoundAC.ChordSpaceGroup_countI_set)
    __swig_setmethods__["countT"] = _CsoundAC.ChordSpaceGroup_countT_set
    __swig_getmethods__["countT"] = _CsoundAC.ChordSpaceGroup_countT_get
    if _newclass:
        countT = _swig_property(_CsoundAC.ChordSpaceGroup_countT_get, _CsoundAC.ChordSpaceGroup_countT_set)
    __swig_setmethods__["countV"] = _CsoundAC.ChordSpaceGroup_countV_set
    __swig_getmethods__["countV"] = _CsoundAC.ChordSpaceGroup_countV_get
    if _newclass:
        countV = _swig_property(_CsoundAC.ChordSpaceGroup_countV_get, _CsoundAC.ChordSpaceGroup_countV_set)
    __swig_setmethods__["opttisForIndexes"] = _CsoundAC.ChordSpaceGroup_opttisForIndexes_set
    __swig_getmethods__["opttisForIndexes"] = _CsoundAC.ChordSpaceGroup_opttisForIndexes_get
    if _newclass:
        opttisForIndexes = _swig_property(_CsoundAC.ChordSpaceGroup_opttisForIndexes_get, _CsoundAC.ChordSpaceGroup_opttisForIndexes_set)
    __swig_setmethods__["indexesForOpttis"] = _CsoundAC.ChordSpaceGroup_indexesForOpttis_set
    __swig_getmethods__["indexesForOpttis"] = _CsoundAC.ChordSpaceGroup_indexesForOpttis_get
    if _newclass:
        indexesForOpttis = _swig_property(_CsoundAC.ChordSpaceGroup_indexesForOpttis_get, _CsoundAC.ChordSpaceGroup_indexesForOpttis_set)
    __swig_setmethods__["voicingsForIndexes"] = _CsoundAC.ChordSpaceGroup_voicingsForIndexes_set
    __swig_getmethods__["voicingsForIndexes"] = _CsoundAC.ChordSpaceGroup_voicingsForIndexes_get
    if _newclass:
        voicingsForIndexes = _swig_property(_CsoundAC.ChordSpaceGroup_voicingsForIndexes_get, _CsoundAC.ChordSpaceGroup_voicingsForIndexes_set)
    __swig_setmethods__["indexesForVoicings"] = _CsoundAC.ChordSpaceGroup_indexesForVoicings_set
    __swig_getmethods__["indexesForVoicings"] = _CsoundAC.ChordSpaceGroup_indexesForVoicings_get
    if _newclass:
        indexesForVoicings = _swig_property(_CsoundAC.ChordSpaceGroup_indexesForVoicings_get, _CsoundAC.ChordSpaceGroup_indexesForVoicings_set)

    def preinitialize(self, N_, range_, g_=1.0):
        """
        preinitialize(ChordSpaceGroup self, int N_, double range_, double g_=1.0)
        preinitialize(ChordSpaceGroup self, int N_, double range_)
        """
        return _CsoundAC.ChordSpaceGroup_preinitialize(self, N_, range_, g_)


    def initialize(self, N_, range_, g_=1.0):
        """
        initialize(ChordSpaceGroup self, int N_, double range_, double g_=1.0)
        initialize(ChordSpaceGroup self, int N_, double range_)
        """
        return _CsoundAC.ChordSpaceGroup_initialize(self, N_, range_, g_)


    def list(self, listheader=True, listopttis=False, listvoicings=False):
        """
        list(ChordSpaceGroup self, bool listheader=True, bool listopttis=False, bool listvoicings=False)
        list(ChordSpaceGroup self, bool listheader=True, bool listopttis=False)
        list(ChordSpaceGroup self, bool listheader=True)
        list(ChordSpaceGroup self)
        """
        return _CsoundAC.ChordSpaceGroup_list(self, listheader, listopttis, listvoicings)


    def createFilename(self, voices, range, g=1.0):
        """
        createFilename(ChordSpaceGroup self, int voices, double range, double g=1.0) -> std::string
        createFilename(ChordSpaceGroup self, int voices, double range) -> std::string
        """
        return _CsoundAC.ChordSpaceGroup_createFilename(self, voices, range, g)


    def createChordSpaceGroup(self, voices, range, g=1.0):
        """
        createChordSpaceGroup(ChordSpaceGroup self, int voices, double range, double g=1.0)
        createChordSpaceGroup(ChordSpaceGroup self, int voices, double range)
        """
        return _CsoundAC.ChordSpaceGroup_createChordSpaceGroup(self, voices, range, g)


    def save(self, stream):
        """save(ChordSpaceGroup self, std::fstream & stream)"""
        return _CsoundAC.ChordSpaceGroup_save(self, stream)


    def load(self, stream):
        """load(ChordSpaceGroup self, std::fstream & stream)"""
        return _CsoundAC.ChordSpaceGroup_load(self, stream)


    def fromChord(self, chord, printme=False):
        """
        fromChord(ChordSpaceGroup self, Chord chord, bool printme=False) -> Eigen::VectorXi
        fromChord(ChordSpaceGroup self, Chord chord) -> Eigen::VectorXi
        """
        return _CsoundAC.ChordSpaceGroup_fromChord(self, chord, printme)


    def toChord(self, *args):
        """
        toChord(ChordSpaceGroup self, int P, int I, int T, int V, bool printme=False) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
        toChord(ChordSpaceGroup self, int P, int I, int T, int V) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
        toChord(ChordSpaceGroup self, Eigen::VectorXi const & pitv, bool printme=False) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
        toChord(ChordSpaceGroup self, Eigen::VectorXi const & pitv) -> std::vector< csound::Chord,std::allocator< csound::Chord > >
        """
        return _CsoundAC.ChordSpaceGroup_toChord(self, *args)


    def __init__(self):
        """__init__(csound::ChordSpaceGroup self) -> ChordSpaceGroup"""
        this = _CsoundAC.new_ChordSpaceGroup()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CsoundAC.delete_ChordSpaceGroup
    __del__ = lambda self: None
ChordSpaceGroup_swigregister = _CsoundAC.ChordSpaceGroup_swigregister
ChordSpaceGroup_swigregister(ChordSpaceGroup)


# Create one global instance of CppSound for CsoundAC to grab.
# Create it in the main module, so that scripts for CsoundAC
# will also work in a standalone Python interpreter.
import sys
import csnd6
sys.modules["__main__"].csound = csnd6.CppSound()
sys.modules["__main__"].csound.thisown = 0
sys.modules["__main__"].csound.setPythonMessageCallback()

# This file is compatible with both classic and new-style classes.