theano/gof/op.py
def c_code(self, node, name, inputs, outputs, sub):
        """
        Required: return the C implementation of an Op.

        Returns C code that does the computation associated to this `Op`,
        given names for the inputs and outputs.

        Parameters
        ----------
        node : Apply instance
            The node for which we are compiling the current c_code.
           The same Op may be used in more than one node.
        name : str
            A name that is automatically assigned and guaranteed to be
            unique.
        inputs : list of strings
            There is a string for each input of the function, and the
            string is the name of a C variable pointing to that input.
            The type of the variable depends on the declared type of
            the input.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.
        outputs : list of strings
            Each string is the name of a C variable where the Op should
            store its output.  The type depends on the declared type of
            the output.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.  In some cases the outputs will be preallocated and
            the value of the variable may be pre-filled.  The value for
            an unallocated output is type-dependent.
        sub : dict of strings
            Extra symbols defined in `CLinker` sub symbols (such as 'fail').
            WRITEME

        Raises
        ------
        MethodNotDefined
            The subclass does not override this method.

        """
        raise utils.MethodNotDefined('%s.c_code' % self.__class__.__name__)

        Required: return the C implementation of an Op.

        Returns C code that does the computation associated to this `Op`,
        given names for the inputs and outputs.

        Parameters
        ----------
        node : Apply instance
            The node for which we are compiling the current c_code.
           The same Op may be used in more than one node.
        name : str
            A name that is automatically assigned and guaranteed to be
            unique.
        inputs : list of strings
            There is a string for each input of the function, and the
            string is the name of a C variable pointing to that input.
            The type of the variable depends on the declared type of
            the input.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.
        outputs : list of strings
            Each string is the name of a C variable where the Op should
            store its output.  The type depends on the declared type of
            the output.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.  In some cases the outputs will be preallocated and
            the value of the variable may be pre-filled.  The value for
            an unallocated output is type-dependent.
        sub : dict of strings
            Extra symbols defined in `CLinker` sub symbols (such as 'fail').
            WRITEME

        Raises
        ------
        MethodNotDefined
            The subclass does not override this method.

        
return the C implementation of an Op.
Returns C code that does the computation associated to this `Op`,
given names for the inputs and outputs.

Parameters

node : Apply instance
The node for which we are compiling the current c_code.
The same Op may be used in more than one node.
name : str
A name that is automatically assigned and guaranteed to be
unique.
inputs : list of strings
There is a string for each input of the function, and the
string is the name of a C variable pointing to that input.
The type of the variable depends on the declared type of
the input.  There is a corresponding python variable that
can be accessed by prepending "py_" to the name in the
list.
outputs : list of strings
Each string is the name of a C variable where the Op should
store its output.  The type depends on the declared type of
the output.  There is a corresponding python variable that
can be accessed by prepending "py_" to the name in the
list.  In some cases the outputs will be preallocated and
the value of the variable may be pre-filled.  The value for
an unallocated output is type-dependent.
sub : dict of strings
Extra symbols defined in `CLinker` sub symbols (such as 'fail').
WRITEME

Raises

MethodNotDefined
The subclass does not override this method.
return the C implementation of an Op . Returns C code that does the computation associated to this ` Op ` given names for the inputs and outputs . Parameters node : Apply instance The node for which we are compiling the current c_code . The same Op may be used in more than one node . name : str A name that is automatically assigned and guaranteed to be unique . inputs : list of strings There is a string for each input of the function and the string is the name of a C variable pointing to that input . The type of the variable depends on the declared type of the input . There is a corresponding python variable that can be accessed by prepending " py_ " to the name in the list . outputs : list of strings Each string is the name of a C variable where the Op should store its output . The type depends on the declared type of the output . There is a corresponding python variable that can be accessed by prepending " py_ " to the name in the list . In some cases the outputs will be preallocated and the value of the variable may be pre - filled . The value for an unallocated output is type - dependent . sub : dict of strings Extra symbols defined in ` CLinker ` sub symbols ( such as ' fail ' ) . WRITEME Raises MethodNotDefined The subclass does not override this method .
def c_code(self, node, name, inputs, outputs, sub):
        raise utils.MethodNotDefined('%s.c_code' % self.__class__.__name__)
def c_code ( self , node , name , inputs , outputs , sub ) : raise utils . MethodNotDefined ( '%s.c_code' % self . __class__ . __name__ )
Required: return the C implementation of an Op.
Required : return the C implementation of an Op .
"""
        Required: return the C implementation of an Op.

        Returns C code that does the computation associated to this `Op`,
        given names for the inputs and outputs.

        Parameters
        ----------
        node : Apply instance
            The node for which we are compiling the current c_code.
           The same Op may be used in more than one node.
        name : str
            A name that is automatically assigned and guaranteed to be
            unique.
        inputs : list of strings
            There is a string for each input of the function, and the
            string is the name of a C variable pointing to that input.
            The type of the variable depends on the declared type of
            the input.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.
        outputs : list of strings
            Each string is the name of a C variable where the Op should
            store its output.  The type depends on the declared type of
            the output.  There is a corresponding python variable that
            can be accessed by prepending "py_" to the name in the
            list.  In some cases the outputs will be preallocated and
            the value of the variable may be pre-filled.  The value for
            an unallocated output is type-dependent.
        sub : dict of strings
            Extra symbols defined in `CLinker` sub symbols (such as 'fail').
            WRITEME

        Raises
        ------
        MethodNotDefined
            The subclass does not override this method.

        """
self
node
name
inputs
outputs
sub