Ticket #3726: sage-3726-part6.patch

a/sage/stats/hmm/all.py

@@ +1 @@
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
+
-from hmm  import DiscreteHiddenMarkovModel
-from chmm import GaussianHiddenMarkovModel

a/sage/stats/hmm/chmm.pxd

@@ +1 @@
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
-
-from hmm cimport HiddenMarkovModel
-
@@ -193 +200 @@
-
-
-    int ghmm_cmodel_free (ghmm_cmodel ** smo)
-
+
+
+
+
-        
-cdef class ContinuousHiddenMarkovModel(HiddenMarkovModel):
-    cdef ghmm_cmodel* m

a/sage/stats/hmm/chmm.pyx

@@ +1 @@
+"""
+Continuous Hidden Markov Models
-
+AUTHORS:
+    -- William Stein (2008)
+    -- The authors of GHMM http://ghmm.sourceforge.net/
+"""
+
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
-
-include "../../ext/stdsage.pxi"
-
-include "misc.pxi"
-
-cdef class ContinuousHiddenMarkovModel(HiddenMarkovModel):
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        self.initialized = False
-        HiddenMarkovModel.__init__(self, A, B, pi)
-        self.m = <ghmm_cmodel*> safe_malloc(sizeof(ghmm_cmodel))
-        # Set number of states
-        self.m.N = self.A.nrows()
+        # Assign model identifier (the name) if specified
+        if name is not None: 
+            name = str(name)
+            self.m.name = <char*> safe_malloc(len(name))
+            strcpy(self.m.name, name)
+        else:
+            self.m.name = NULL
+            
+
+    def name(self):
+        """
+        Return the name of this model.
+
+        OUTPUT:
+            string or None
+
+        EXAMPLES:
+            sage: m = hmm.GaussianHiddenMarkovModel([[0.4,0.6],[0.1,0.9]], [(0.0,1.0),(1,1)], [1,0], 'Test Model')
+            sage: m.name()
+            'Test Model'
+
+        If the model is not explicitly named then this function returns None:
+            sage: m = hmm.GaussianHiddenMarkovModel([[0.4,0.6],[0.1,0.9]], [(0.0,1.0),(1,1)], [1,0])
+            sage: m.name()
+            sage: m.name() is None
+            True
+        """
+        if self.m.name:
+            s = str(self.m.name)
+            return s
+        else:
+            return None
+            
-
-cdef class GaussianHiddenMarkovModel(ContinuousHiddenMarkovModel):
-
+r
-    Create a Gaussian Hidden Markov Model.  The probability
-    distribution associated with each state is a Gaussian
-    distribution.
@@ -26 +96 @@
-              Gaussian distributions associated to each state
-        pi -- list of floats that sums to 1.0; these are
-              the initial probabilities of each hidden state
-
+a string
-
-    EXAMPLES:
-    Define the transition matrix:
@@ -38 +108 @@
-    The initial probabilities per state:
-        sage: pi = [1,0,0]
-
-
-
+
+
+
+
+
+
+
+
+
+
-    """
-    def __init__(self, A, B, pi, name=None):
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        # Set number of outputs.  This is 1 here because each
-        # output is a single Gaussian distribution.
@@ -51 +149 @@
-        # Set the model type to continuous
-        self.m.model_type = GHMM_kContinuousHMM
-
-        # Assign model identifier if specified
-        if name is not None: 
-            name = str(name)
-            self.m.name = name
-        else:
-            self.m.name = NULL
-            
-        # 1 transition matrix
-        self.m.cos   =  1
-        # Set that no a prior model probabilities are set.
@@ -69 +160 @@
-        cdef ghmm_cstate* states = <ghmm_cstate*> safe_malloc(sizeof(ghmm_cstate) * self.m.N)
-        cdef ghmm_cstate* state
-        cdef ghmm_c_emission* e
+        cdef Py_ssize_t i, j, k
-
-        for i in range(self.m.N):
-            # Parameters of normal distribution
@@ -78 +170 @@
-            state.M     = 1
-            state.pi    = pi[i]
-            state.desc  = NULL
-            state.out_states = 0
-            state.in_states = 0
-            e = <ghmm_c_emission*> safe_malloc(sizeof(ghmm_c_emission))
-            e.type      = 0  # normal
-            e.dimension = 1
@@ -91 +181 @@
-            e.sigmainv  = NULL
-            state.e     = e
-            state.c     = to_double_array([1.0])
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        # Set states
-        self.m.s = states
@@ -102 +217 @@
-        self.initialized = True
-
-    def __dealloc__(self):
+        """
+        Dealloc the memory used by this Gaussian HMM, but only if the
+        HMM was successfully initialized.
+
+        EXAMPLES:  
+            sage: m = hmm.GaussianHiddenMarkovModel([[1.0]], [(0.0,1.0)], [1])   # implicit doctest
+            sage: del m
+        """
-        if self.initialized:
-            ghmm_cmodel_free(&self.m)
+
+    def __copy__(self):
+        """
+        Return a copy of this Gaussian HMM.
+        
+        EXAMPLES:
+            sage: m = hmm.GaussianHiddenMarkovModel([[0.4,0.6],[0.1,0.9]], [(0.0,1.0),(1,1)], [1,0], 'NAME')
+            sage: copy(m)
+            Gaussian Hidden Markov Model NAME with 2 States
+            Transition matrix:
+            [0.4 0.6]
+            [0.1 0.9]
+            Emission parameters:
+            [(0.0, 1.0), (1.0, 1.0)]
+            Initial probabilities: [1.0, 0.0]
+        """
+        
+        return GaussianHiddenMarkovModel(self.transition_matrix(), self.emission_parameters(),
+                                         self.initial_probabilities(), self.name())
+
+    def __cmp__(self, other):
+        """
+        Compare two Gaussian HMM's.
+
+        INPUT:
+            self, other -- objects; if other is not a Gaussian HMM compare types.
+        OUTPUT:
+            -1,0,1
+
+        The transition matrices are compared, then the emission
+        parameters, and the initial probabilities.  The names are not
+        compared, so two GHMM's with the same parameters but different
+        names compare to be equal.
+
+        EXAMPLES:
+            sage: m = hmm.GaussianHiddenMarkovModel([[0.4,0.6],[0.1,0.9]], [(0.0,1.0),(1,1)], [1,2], "Test 1")
+            sage: m.__cmp__(m)
+            0
+
+        Note that the name doesn't matter:
+            sage: n = hmm.GaussianHiddenMarkovModel([[0.4,0.6],[0.1,0.9]], [(0.0,1.0),(1,1)], [1,2], "Test 2")
+            sage: m.__cmp__(n)
+            0
+
+        Normalizing fixes the initial probabilities, hence m and n are no longer equal.
+            sage: n.normalize()
+            sage: m.__cmp__(n)
+            1
+        """
+        if not isinstance(other, GaussianHiddenMarkovModel):
+            return cmp(type(self), type(other))
+
+        if self is other: return 0  # easy special case
+        
+        cdef GaussianHiddenMarkovModel o = other
+        if self.m.N < o.m.N:
+            return -1
+        elif self.m.N > o.m.N:
+            return 1
+        cdef Py_ssize_t i, j
+
+        # The code below is somewhat long and tedious because I want it to be
+        # very fast.  All it does is explicitly loop through the transition
+        # matrix, emission parameters and initial state probabilities checking
+        # that they agree, and if not returning -1 or 1.
+        # Compare transition matrices
+        for i from 0 <= i < self.m.N:
+            for j from 0 <= j < self.m.s[i].out_states:
+                if self.m.s[i].out_a[0][j] < o.m.s[i].out_a[0][j]:
+                    return -1
+                elif self.m.s[i].out_a[0][j] > o.m.s[i].out_a[0][j]:
+                    return 1
+
+        # Compare emissions parameters
+        for i from 0 <= i < self.m.N:
+            if self.m.s[i].e.mean.val < o.m.s[i].e.mean.val:
+                return -1
+            elif self.m.s[i].e.mean.val > o.m.s[i].e.mean.val:
+                return 1
+            if self.m.s[i].e.variance.val < o.m.s[i].e.variance.val:
+                return -1
+            elif self.m.s[i].e.variance.val > o.m.s[i].e.variance.val:
+                return 1
+            
+        # Compare initial state probabilities
+        for 0 <= i < self.m.N:
+            if self.m.s[i].pi < o.m.s[i].pi:
+                return -1
+            elif self.m.s[i].pi > o.m.s[i].pi:
+                return 1
+
+        return 0
-
-    def __repr__(self):
-        """
@@ -114 +329 @@
-
-        EXAMPLES:
-            sage: m = hmm.GaussianHiddenMarkovModel([[0.0,1.0,0],[0.5,0.0,0.5],[0.3,0.3,0.4]], [(0.0,1.0), (-1.0,0.5), (1.0,0.2)], [1,0,0])
-a
-"Discrete Hidden Markov Model (2 states, 2 outputs)\nInitial probabilities: [0.5, 0.5]\nTransition matrix:\n[0.1 0.9]\n[0.1 0.9]\nEmission matrix:\n[0.9 0.1]\n[0.1 0.9]\nEmission symbols: [3/4, 'abc']"
+m
+'Gaussian Hidden Markov Model with 3 States\nTransition matrix:\n[0.0 1.0 0.0]\n[0.5 0.0 0.5]\n[0.3 0.3 0.4]\nEmission parameters:\n[(0.0, 1.0), (-1.0, 0.5), (1.0, 0.20000000000000001)]\nInitial probabilities: [1.0, 0.0, 0.0]'
-        """
-(%s states, %s outputs)
+with %s States
-            ' ' + self.m.name if self.m.name else '',
-
-
+
-        s += '\nTransition matrix:\n%s'%self.transition_matrix()
-        s += '\nEmission parameters:\n%s'%self.emission_parameters()
+        s += '\nInitial probabilities: %s'%self.initial_probabilities()
-        return s
-
-    def initial_probabilities(self):
@@ -135 +350 @@
-        EXAMPLES:
-            sage: m = hmm.GaussianHiddenMarkovModel([[0.0,1.0,0],[0.5,0.0,0.5],[0.3,0.3,0.4]], [(0.0,1.0), (-1.0,0.5), (1.0,0.2)], [0.4,0.3,0.3])
-            sage: m.initial_probabilities()
-, 0.3, 0.3
+0000000000000002, 0.29999999999999999, 0.29999999999999999
-        """
-        cdef Py_ssize_t i
-        return [self.m.s[i].pi for i in range(self.m.N)]
-    
-, list_only=True
+
-        """
-        Return the hidden state transition matrix. 
+
+        OUTPUT:
+            matrix whose rows give the transition probabilities of the
+            Hidden Markov Model states.
-        
-        EXAMPLES:
-            sage: m = hmm.GaussianHiddenMarkovModel([[0.0,1.0,0],[0.5,0.0,0.5],[0.3,0.3,0.4]], [(0.0,1.0), (-1.0,0.5), (1.0,0.2)], [1,0,0])
-            sage: m.transition_matrix()
-
-
+
+
+
-        """
-        cdef Py_ssize_t i, j
+        # Update the state of the "immutable" matrix A, then return a reference to it.
-        for i from 0 <= i < self.m.N:
-            for j from 0 <= j < self.m.s[i].out_states:
-                self.A.set_unsafe_double(i,j,self.m.s[i].out_a[0][j])
@@ -158 +379 @@
-
-    def emission_parameters(self):
-        """
-
+
+
+
+
-        
-        EXAMPLES:
-0,1.0,0],[0.5,0.0,0.5],[0.3,0.3,0.4]], [(0.0,1.0), (-1.0,0.5), (1.0,0.2)], [0.1,0.4,0.5]
+4,0.6],[0.1,0.9]], [(1.5,2),(-1,3)], [1,0], 'NAME'
-            sage: m.emission_parameters()
-0.0, 1.0), (-1.0, 0.5), (1.0, 0.20000...
+1.5, 2.0), (-1.0, 3.0
-        """
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

a/sage/stats/hmm/hmm.pxd

@@ +1 @@
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
+
-from sage.matrix.matrix_real_double_dense cimport Matrix_real_double_dense
-
-cdef extern from "ghmm/ghmm.h":

a/sage/stats/hmm/hmm.pyx

@@ -11 +11 @@
-   * continuous hmm's
-"""
-
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
+
-import math
-
-from sage.matrix.all import is_Matrix, matrix
@@ -22 +30 @@
-include "misc.pxi"
-
-cdef class HiddenMarkovModel:
+    """
+    Abstract base class for all Hidden Markov Models.
+
+    INPUT:
+        A -- matrix or list
+        B -- matrix or list
+        pi -- list of floats
+
+    EXAMPLES:
+    One shouldn't directly call this constructor since this class is an abstract
+    base class.  
+        sage: sage.stats.hmm.hmm.HiddenMarkovModel([[0.4,0.6],[1,0]], [[1,0],[0.5,0.5]], [0.5,0.5])
+        <sage.stats.hmm.hmm.HiddenMarkovModel object at ...>
+    """
-    def __init__(self, A, B, pi):
+        """
+        INPUT:
+            A -- matrix or list
+            B -- matrix or list
+            pi -- list of floats
+
+        EXAMPLES:
+            sage: hmm.DiscreteHiddenMarkovModel([[1]], [[0.0,1.0]], [1])
+            Discrete Hidden Markov Model with 1 States and 2 Emissions
+            Transition matrix:
+            [1.0]
+            Emission matrix:
+            [0.0 1.0]
+            Initial probabilities: [1.0]
+        """
+        # Convert A to a matrix
-        if not is_Matrix(A):
-
+
+
+
+
-        if not is_Matrix(B):
-
+
+
+
+
-        if not A.is_square():
+            print A.parent()
-            raise ValueError, "A must be square"
-        if A.nrows() != B.nrows():
-            raise ValueError, "number of rows of A and B must be the same"
+
+        # Make sure A and B are over RDF.
-        if A.base_ring() != RDF:
-            A = A.change_ring(RDF)
-        if B.base_ring() != RDF:
-            B = B.change_ring(RDF)
-
+        # Make sure the initial probabilities are all floats. 
-        self.pi = [float(x) for x in pi]
-        if len(self.pi) != A.nrows():
-            raise ValueError, "length of pi must equal number of rows of A"
-
+        # Record the now validated matrices A and B as attributes.
+        # They get used later as attributes in the constructors for
+        # derived classes.
-        self.A = A
-        self.B = B
-
@@ -56 +107 @@
-            name -- (optional) name of the model
-
-        EXAMPLES:
-
-
-
+
-            sage: a = hmm.DiscreteHiddenMarkovModel([[0.2,0.8],[0.5,0.5]], [[1,0],[0,1]], [0,1])
-            
-        """
-
+
+
+
+
-        HiddenMarkovModel.__init__(self, A, B, pi)
-
-        cdef Py_ssize_t i, j, k
-        self.set_emission_symbols(emission_symbols)
-
-        self.m = <ghmm_dmodel*> safe_malloc(sizeof(ghmm_dmodel))
@@ -101 +151 @@
-        silent_states = []
-        tmp_order     = []
-        
-
+
+
+
-            v = self.B[i]
-
-            # Get a reference to the i-th state for convenience of the notation below.
@@ -127 +179 @@
-
-            silent_states.append( 1 if sum(v) == 0 else 0)
-
-out probabilities, i.e., the probabilities that each
-symbol will be emitted from this state. 
+"out" probabilities, i.e., the probabilities to
+transition to another hidden state from this state.
-            v = self.A[i]
-
-
+
-            state.out_states = k
-            state.out_id = <int*> safe_malloc(sizeof(int)*k)
-            state.out_a  = <double*> safe_malloc(sizeof(double)*k)
-in range(k)
-nz[j]
-nz[j]
+from 0 <= j < k
+j
+j
-
-            # Set "in" probabilities
-            v = self.A.column(i)
-            nz = v.nonzero_positions()
-            k = len(nz)
-            state.in_states = k
-            state.in_id = <int*> safe_malloc(sizeof(int)*k)
-            state.in_a  = <double*> safe_malloc(sizeof(double)*k)
-in range(k)
-nz[j]
-nz[j]
+from 0 <= j < k
+j
+j
-                
-            state.fix = 0
-                
-        self.m.s = states
-        self.initialized = True
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
+        cdef DiscreteHiddenMarkovModel o = other
+        if self.m.N < o.m.N:
+            return -1
+        elif self.m.N > o.m.N:
+            return 1
+        cdef Py_ssize_t i, j
+
+        # This code is similar to code in chmm.pyx, but with several small differences.
+        
+        # Compare transition matrices
+        for i from 0 <= i < self.m.N:
+            for j from 0 <= j < self.m.s[i].out_states:
+                if self.m.s[i].out_a[j] < o.m.s[i].out_a[j]:
+                    return -1
+                elif self.m.s[i].out_a[j] > o.m.s[i].out_a[j]:
+                    return 1
+
+        # Compare emission matrices
+        for i from 0 <= i < self.m.N:
+            for j from 0 <= j < self.B._ncols:
+                if self.m.s[i].b[j] < o.m.s[i].b[j]:
+                    return -1
+                elif self.m.s[i].b[j] > o.m.s[i].b[j]:
+                    return 1
+                
+        # Compare initial state probabilities
+        for 0 <= i < self.m.N:
+            if self.m.s[i].pi < o.m.s[i].pi:
+                return -1
+            elif self.m.s[i].pi > o.m.s[i].pi:
+                return 1
+
+        return 0
+
-    def __dealloc__(self):
+        """
+        Deallocate memory allocated by the HMM.
+
+        EXAMPLES:
+            sage: a = hmm.DiscreteHiddenMarkovModel([[0.2,0.8],[0.5,0.5]], [[1,0],[0,1]], [0,1])  # indirect doctest
+            sage: del a
+        """
-        if self.initialized:
-            ghmm_dmodel_free(&self.m)
-
@@ -184 +293 @@
-        EXAMPLES:
-            sage: a = hmm.DiscreteHiddenMarkovModel([[0.1,0.9],[0.1,0.9]], [[0.9,0.1],[0.1,0.9]], [0.5,0.5], [3/4, 'abc'])
-            sage: a.__repr__()
-(2 states, 2 outputs)\nInitial probabilities: [0.5, 0.5]\nTransition matrix:\n[0.1 0.9]\n[0.1 0.9]\nEmission matrix:\n[0.9 0.1]\n[0.1 0.9
+with 2 States and 2 Emissions\nTransition matrix:\n[0.1 0.9]\n[0.1 0.9]\nEmission matrix:\n[0.9 0.1]\n[0.1 0.9]\nInitial probabilities: [0.5, 0.5
-        """
-(%s states, %s outputs)
+with %s States and %s Emissions
-            ' ' + self.m.name if self.m.name else '',
-            self.m.N, self.m.M)
-        s += '\nInitial probabilities: %s'%self.initial_probabilities()
-        s += '\nTransition matrix:\n%s'%self.transition_matrix()
-        s += '\nEmission matrix:\n%s'%self.emission_matrix()
+        s += '\nInitial probabilities: %s'%self.initial_probabilities()
-        if self._emission_symbols_dict:
-            s += '\nEmission symbols: %s'%self._emission_symbols
-        return s
@@ -251 +360 @@
-            sage: a = hmm.DiscreteHiddenMarkovModel([[0.5,1],[1.2,0.9]], [[1,0.5],[0.5,1]], [0.1,1.2])
-            sage: a.normalize()
-            sage: a
-
-
+
-            Transition matrix:
-            [0.333333333333 0.666666666667]
-            [0.571428571429 0.428571428571]
-            Emission matrix:
-            [0.666666666667 0.333333333333]
-            [0.333333333333 0.666666666667]
+            Initial probabilities: [0.076923076923076927, 0.92307692307692302]
-        """
-        ghmm_dmodel_normalize(self.m)
-
@@ -491 +600 @@
-        Now the model's emission matrix changes since it is much
-        more likely to emit 1 than 0.  
-            sage: a
-
-
+
-            Transition matrix:
-            [0.5 0.5]
-            [0.5 0.5]
-            Emission matrix:
-            [0.166666666667 0.833333333333]
-            [0.166666666667 0.833333333333]
+            Initial probabilities: [0.5, 0.5]
-
-        Note that 1/6 = 1.666...:
-            sage: 1.0/6
@@ -509 +618 @@
-            sage: a = hmm.DiscreteHiddenMarkovModel([[0.5,0.5],[0.5,0.5]], [[0.5,0.5],[0.5,0.5]], [0.5,0.5], ['up','down'])
-            sage: a.baum_welch([['up','up'], ['down','up']])
-            sage: a
-
-
+
-            Transition matrix:
-            [0.5 0.5]
-            [0.5 0.5]
-            Emission matrix:
-            [0.75 0.25]
-            [0.75 0.25]
-
+
+
-
-        NOTE: Training for models including silent states is not yet supported.
-
@@ -544 +653 @@
-##################################################################################
-
-cdef ghmm_dseq* malloc_ghmm_dseq(seqs) except NULL:
+    """
+    Allocate a discrete sequence of samples.
+
+    INPUT:
+        seqs -- a list of sequences
+
+    OUTPUT:
+        C pointer to ghmm_dseq
+    """
-    cdef ghmm_dseq* d = ghmm_dseq_calloc(len(seqs))
-    if d == NULL:
-        raise MemoryError

a/sage/stats/hmm/misc.pxi

@@ +1 @@
+#############################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version at your option.
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+#############################################################################
+
+cdef extern from "string.h":
+    char *strcpy(char *s1, char *s2)
-
-cdef double* to_double_array(v) except NULL:
+    """
+    Transform a Python list of floats to a C array of doubles.  The caller is
+    responsible for deallocating the resulting memory.
+    
+    INPUT:
+        v -- a list of objects coercible to floats
+    OUTPUT:
+        a newly allocated C array of doubles
+    """
-    cdef double x
-    cdef double* w = <double*> safe_malloc(sizeof(double)*len(v))
-    cdef Py_ssize_t i = 0
@@ -9 +28 @@
-    return w
-
-cdef int* to_int_array(v) except NULL:
+    """
+    Transform a Python list of ints to a C array of ints.  The caller is
+    responsible for deallocating the resulting memory.
+    
+    INPUT:
+        v -- a list of objects coercible to ints
+    OUTPUT:
+        a newly allocated C array of ints
+    """
-    cdef int x
-    cdef int* w = <int*> safe_malloc(sizeof(int)*len(v))
-    cdef Py_ssize_t i = 0
@@ -21 +49 @@
-    """
-    malloc the given bytes of memory and check that the malloc
-    succeeds -- if not raise a MemoryError.
+
+    INPUT:
+        bytes -- a nonnegatie integer
+        
+    OUTPUT:
+        void pointer or raise a MemoryError. 
-    """
-    cdef void* t = sage_malloc(bytes)
-    if not t: