path: root/bindings/python/pygmathlib/gmathlib.pyx

'''
gMathLib, mathematic expressions handling library

 # Python bindings

Author : Guillaume Seguin
Email : guillaume@segu.in

Copyright (c) 2007 Guillaume Seguin <guillaume@segu.in>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA  02110-1301, USA.
'''

ctypedef unsigned int bool

cdef extern from 'string.h':
    ctypedef int size_t
    cdef extern char *strdup (char *s)
    cdef extern void free (void *f)

ctypedef int guint
cdef extern from "glib.h":
    ctypedef struct GHashTable
    ctypedef struct GSList:
        void    *data
        GSList  *next
    cdef extern void g_slist_free (GSList *list)

cdef extern from "Python.h":
    object PyString_FromStringAndSize (char *string, int size)

cdef struct GMathContext
cdef struct GMathInputModule
cdef struct GMathOutputModule
cdef struct GMathFormula
cdef struct GMathTemplate
cdef struct GMathSymbol

cdef struct GMathContext:
    GHashTable      *templates
    GHashTable      *input_modules
    GHashTable      *output_modules

cdef struct GMathFormula:
    GMathContext    *context
    GMathSymbol     *root

cdef struct GMathTemplate:
    bool            has_value
    unsigned int    children_count

cdef struct GMathSymbol:
    char            *type
    char            *value

    void            **children

    void            *parent

    GMathTemplate   *template
    GMathContext    *context

cdef struct GMathArray:
    guint           rows
    guint           columns

    char            *alignment

    GMathSymbol     **children

    GMathSymbol     *parent

cdef enum GMathSupportStatus:
    GMathSupportError    = -2
    GMathNoIntrospection = -1
    GMathUnsupported     = 0
    GMathSupported       = 1

cdef extern GMathContext* gmathcontext_new ()
cdef extern void gmathcontext_free (GMathContext *context)
cdef extern GSList* gmathcontext_get_template_names (GMathContext *context)
cdef extern GMathSupportStatus gmathcontext_get_template_supported (
                   GMathContext *context, char *module, char *name)
cdef extern GMathInputModule* gmathcontext_get_input_module ( \
                GMathContext *context, char *name)
cdef extern GMathOutputModule* gmathcontext_get_output_module ( \
                GMathContext *context, char *name)
cdef extern bool gmathcontext_load_input_module (GMathContext *context,
                                                 char *name)
cdef extern bool gmathcontext_load_output_module (GMathContext *context,
                                                  char *name)

cdef extern GMathFormula* gmathcontext_import (GMathContext *context,
                                               char *module,
                                               char *data)
cdef extern GMathFormula* gmathformula_new (GMathContext *context)
cdef extern void gmathformula_free (GMathFormula *formula)
cdef extern void gmathformula_set_root (GMathFormula *formula,
                                        GMathSymbol *symbol)
cdef extern size_t gmathformula_export (GMathFormula *formula, char *module,
                                        char **data)

cdef extern GMathSymbol* gmathsymbol_new (GMathContext *context, char *type)
cdef extern GMathSymbol* gmathsymbol_new_array (GMathContext *context,
                                                guint rows, guint columns)
cdef extern bool gmathsymbol_set_array_child (GMathSymbol* array_sym,
                                              GMathSymbol* new_child,
                                              guint row, guint column)
cdef extern bool gmathsymbol_set_array_alignment (GMathSymbol* array_sym,
                                                  char alignment,
                                                  guint column)
cdef extern void gmathsymbol_free (GMathSymbol *symbol)
cdef extern void gmathsymbol_set_value (GMathSymbol *symbol, char *value)
cdef extern void gmathsymbol_set_child (GMathSymbol *symbol,
                                        GMathSymbol *child, int index)
cdef extern GMathSymbol* gmathsymbol_get_child (GMathSymbol *symbol,
                                                int index)

cdef class Symbol:
    cdef GMathSymbol    *csymbol
    cdef object         context
    cdef object         children

    def __new__ (self, context, symtype = "", symbol = None, c_symbol = False,
                 copy = None):
        cdef GMathSymbol  *child
        cdef GMathContext *ccontext
        self.context = context
        ccontext = <GMathContext *> context.c_context
        if c_symbol:
            self.csymbol = <GMathSymbol *> symbol
        elif symtype:
            self.csymbol = gmathsymbol_new (ccontext, symtype)

        if copy:
            self.children = [None] * len (copy.children_)
            for i in range (0, len (copy.children_)):
                if copy.children_[i]:
                    self.set_child (copy.children_[i].copy (deep = True), i)
            return

        self.children = []
        for i in range (0, self.csymbol.template.children_count):
            child = gmathsymbol_get_child (self.csymbol, i)
            if not child:
                self.children.append (None)
                continue
            self.children.append (Symbol (context, symbol = <object> child,
                                          c_symbol = True))

    def set_child (self, child, index):
        cdef GMathSymbol *cchild
        if index >= self.csymbol.template.children_count:
            return
        self.children[index] = child
        if child:
            cchild = <GMathSymbol *> child.c_symbol
        else:
            cchild = NULL
        gmathsymbol_set_child (self.csymbol, cchild, index)

    def copy (self, deep = False):
        if deep:
            copy = self
        else:
            copy = None
        symbol = Symbol (self.context, symtype = self.type, copy = copy)
        symbol.value = self.value
        return symbol

    def free (self):
        for i in range (0, len (self.children)):
            child = self.children[i]
            if child:
                child.free ()
                self.set_child (None, i)
        gmathsymbol_free (self.csymbol)
        self.csymbol = NULL

    def __dealloc__ (self):
        self.free ()

    property type:
        def __get__ (self):
            if self.csymbol == NULL or self.csymbol.type == NULL:
                return ""
            return self.csymbol.type

    property value:
        def __get__ (self):
            if self.csymbol == NULL or self.csymbol.value == NULL:
                return ""
            return self.csymbol.value

        def __set__ (self, value):
            gmathsymbol_set_value (self.csymbol, value)

    property children_:
        def __get__ (self):
            return self.children

    property c_symbol:
        def __get__ (self):
            if self.csymbol == NULL:
                return None
            return <object> self.csymbol

cdef class Array:
    cdef GMathSymbol    *csymbol
    cdef object         context
    cdef object         children
    cdef object         _rows
    cdef object         _columns

    def __new__ (self, context, rows, columns):
        cdef GMathSymbol *child
        cdef GMathContext *ccontext
        self.context = context
        ccontext = <GMathContext *> context.c_context
        self.csymbol = gmathsymbol_new_array (ccontext, rows, columns)

        self._rows = rows
        self._columns = columns

        self.children = [None] * rows * columns

    def set_child (self, child, row, column):
        cdef GMathSymbol *cchild
        if row >= self.rows or column >= self.columns:
            return
        self.children[row * self.columns + column] = child
        if child:
            cchild = <GMathSymbol *> child.c_symbol
        else:
            cchild = NULL
        gmathsymbol_set_array_child (self.csymbol, cchild, row, column)

    def set_alignment (self, alignment, column):
        if column >= self.columns:
            return
        if len (alignment) != 1:
            return
        gmathsymbol_set_array_alignment (self.csymbol, ord (alignment), column)

    def free (self):
        for i in range (0, len (self.children)):
            child = self.children[i]
            if child:
                child.free ()
                column = i % self.columns
                row = int (float (i - column) / self.columns)
                self.set_child (None, row, column)
        gmathsymbol_free (self.csymbol)
        self.csymbol = NULL

    def __dealloc__ (self):
        self.free ()

    property rows:
        def __get__ (self):
            return self._rows

    property columns:
        def __get__ (self):
            return self._columns

    property c_symbol:
        def __get__ (self):
            if self.csymbol == NULL:
                return None
            return <object> self.csymbol

cdef class Formula:
    cdef GMathFormula   *cformula
    cdef object         context
    cdef object         root

    def __new__ (self, context, formula = None, c_formula = False):
        cdef GMathContext *ccontext
        self.context = context
        self.context.register_formula (self)
        ccontext = <GMathContext *> context.c_context
        if c_formula:
            self.cformula = <GMathFormula *> formula
        else:
            self.cformula = gmathformula_new (ccontext)
        if self.cformula.root != NULL:
            self.root = Symbol (self.context,
                                symbol = <object> self.cformula.root,
                                c_symbol = True)
        else:
            self.root = None

    def free (self):
        if self.root:
            self.root.free ()
        self.set_root (None)
        gmathformula_free (self.cformula)

    def __dealloc__ (self):
        self.free ()

    def set_root (self, root):
        cdef GMathSymbol    *croot
        if root:
            croot = <GMathSymbol *> root.c_symbol
        else:
            croot = NULL
        gmathformula_set_root (self.cformula, croot)
        self.root = root

    def export (self):
        cdef char   *cdata
        cdef size_t size
        if not self.context.output_module:
            raise RuntimeError, "no output module selected"
        size = gmathformula_export (self.cformula, self.context.output_module,
                                    &cdata)
        if not size:
            return None
        data = PyString_FromStringAndSize (cdata, size)
        free (cdata)
        return data

    property c_formula:
        def __get__ (self):
            if self.cformula == NULL:
                return None
            return <object> self.cformula

cdef class Context:
    cdef GMathContext   *ccontext
    cdef object         _input_module
    cdef object         _output_module
    cdef object         formulas

    def __new__ (self, context = None, c_context = False):
        if c_context:
            self.ccontext = <GMathContext *> context
        else:
            self.ccontext = gmathcontext_new ()
        self.input_module = None
        self.output_module = None
        self.formulas = []

    def __dealloc__ (self):
        for formula in self.formulas:
            formula.free ()
        gmathcontext_free (self.ccontext)

    def get_template_names (self):
        cdef GSList *list, *list0
        list0 = gmathcontext_get_template_names (self.ccontext)
        list = list0
        ret = []
        while list != NULL:
            ret.append (strdup (<char *> list.data))
            free (list.data)
            list = list.next
        g_slist_free (<GSList *> list0)
        return ret

    def get_template_supported (self, name, module = None):
        if not module:
            if not self.output_module:
                raise RuntimeError, "no output module selected"
            module = self.output_module
        s = gmathcontext_get_template_supported (self.ccontext, module, name)
        if s == GMathSupported:
            return True
        elif s == GMathUnsupported:
            return False
        raise RuntimeError, "%s module doesn't support introspection" % module

    def load_input_module (self, name):
        gmathcontext_load_input_module (self.ccontext, name)

    def load_output_module (self, name):
        gmathcontext_load_output_module (self.ccontext, name)

    def import_from_data (self, data):
        if not self.input_module:
            raise RuntimeError, "no input module selected"
        cdef GMathFormula *formula
        formula = gmathcontext_import (self.ccontext, self.input_module, data)
        if formula == NULL:
            return None
        return Formula (self, <object> formula)

    def register_formula (self, formula):
        self.formulas.append (formula)

    def Atom (self, value):
        symbol = self.Symbol (symtype = "atom")
        symbol.value = value
        return symbol

    def Formula (self):
        return Formula (self)

    def Symbol (self, symtype = "", symbol = None):
        return Symbol (self, symtype, symbol)

    def Array (self, rows, columns):
        return Array (self, rows, columns)

    property input_module:
        def __get__ (self):
            return self._input_module

        def __set__ (self, name):
            if name and not gmathcontext_get_input_module (self.ccontext,
                                                           name):
                self.load_input_module (name)
                if not gmathcontext_get_input_module (self.ccontext, name):
                    raise RuntimeError, "%s input module not found." % name
            self._input_module = name

    property output_module:
        def __get__ (self):
            return self._output_module

        def __set__ (self, name):
            if name and not gmathcontext_get_output_module (self.ccontext,
                                                           name):
                self.load_output_module (name)
                if not gmathcontext_get_output_module (self.ccontext, name):
                    raise RuntimeError, "%s output module not found." % name
            self._output_module = name

    property c_context:
        def __get__ (self):
            if self.ccontext == NULL:
                return None
            return <object> self.ccontext