diff options
Diffstat (limited to 'numpy/f2py/tests')
21 files changed, 2337 insertions, 0 deletions
diff --git a/numpy/f2py/tests/array_from_pyobj/__init__.py b/numpy/f2py/tests/array_from_pyobj/__init__.py new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/numpy/f2py/tests/array_from_pyobj/__init__.py diff --git a/numpy/f2py/tests/array_from_pyobj/setup.py b/numpy/f2py/tests/array_from_pyobj/setup.py new file mode 100644 index 000000000..520e3dd94 --- /dev/null +++ b/numpy/f2py/tests/array_from_pyobj/setup.py @@ -0,0 +1,25 @@ +import os +def configuration(parent_name='',top_path=None): + from numpy.distutils.misc_util import Configuration + + config = Configuration('array_from_pyobj',parent_name,top_path) + #import numpy.f2py as f2py + #f2pydir=os.path.dirname(os.path.abspath(f2py.__file__)) + f2pydir=os.path.join(config.local_path,'..','..') + fobjhsrc = os.path.join(f2pydir,'src','fortranobject.h') + fobjcsrc = os.path.join(f2pydir,'src','fortranobject.c') + config.add_extension('wrap', + sources = ['wrapmodule.c',fobjcsrc], + include_dirs = [os.path.dirname(fobjhsrc)], + depends = [fobjhsrc,fobjcsrc], + define_macros = [('DEBUG_COPY_ND_ARRAY',1), + #('F2PY_REPORT_ON_ARRAY_COPY',1), + #('F2PY_REPORT_ATEXIT',1) + ] + ) + + return config + +if __name__ == "__main__": + from numpy.distutils.core import setup + setup(configuration=configuration) diff --git a/numpy/f2py/tests/array_from_pyobj/tests/test_array_from_pyobj.py b/numpy/f2py/tests/array_from_pyobj/tests/test_array_from_pyobj.py new file mode 100644 index 000000000..e1d4a47a6 --- /dev/null +++ b/numpy/f2py/tests/array_from_pyobj/tests/test_array_from_pyobj.py @@ -0,0 +1,515 @@ +import unittest +import sys +import copy + +from numpy.testing import * +from numpy import array, alltrue, ndarray, asarray, can_cast,zeros, dtype +from numpy.core.multiarray import typeinfo + +set_package_path() +from array_from_pyobj import wrap +del sys.path[0] + +def flags_info(arr): + flags = wrap.array_attrs(arr)[6] + return flags2names(flags) + +def flags2names(flags): + info = [] + for flagname in ['CONTIGUOUS','FORTRAN','OWNDATA','ENSURECOPY', + 'ENSUREARRAY','ALIGNED','NOTSWAPPED','WRITEABLE', + 'UPDATEIFCOPY','BEHAVED','BEHAVED_RO', + 'CARRAY','FARRAY' + ]: + if abs(flags) & getattr(wrap,flagname): + info.append(flagname) + return info + +class Intent: + def __init__(self,intent_list=[]): + self.intent_list = intent_list[:] + flags = 0 + for i in intent_list: + if i=='optional': + flags |= wrap.F2PY_OPTIONAL + else: + flags |= getattr(wrap,'F2PY_INTENT_'+i.upper()) + self.flags = flags + def __getattr__(self,name): + name = name.lower() + if name=='in_': name='in' + return self.__class__(self.intent_list+[name]) + def __str__(self): + return 'intent(%s)' % (','.join(self.intent_list)) + def __repr__(self): + return 'Intent(%r)' % (self.intent_list) + def is_intent(self,*names): + for name in names: + if name not in self.intent_list: + return False + return True + def is_intent_exact(self,*names): + return len(self.intent_list)==len(names) and self.is_intent(*names) + +intent = Intent() + +class Type(object): + + _type_names = ['BOOL','BYTE','UBYTE','SHORT','USHORT','INT','UINT', + 'LONG','ULONG','LONGLONG','ULONGLONG', + 'FLOAT','DOUBLE','LONGDOUBLE','CFLOAT','CDOUBLE', + 'CLONGDOUBLE'] + _type_cache = {} + + _cast_dict = {'BOOL':['BOOL']} + _cast_dict['BYTE'] = _cast_dict['BOOL'] + ['BYTE'] + _cast_dict['UBYTE'] = _cast_dict['BOOL'] + ['UBYTE'] + _cast_dict['BYTE'] = ['BYTE'] + _cast_dict['UBYTE'] = ['UBYTE'] + _cast_dict['SHORT'] = _cast_dict['BYTE'] + ['UBYTE','SHORT'] + _cast_dict['USHORT'] = _cast_dict['UBYTE'] + ['BYTE','USHORT'] + _cast_dict['INT'] = _cast_dict['SHORT'] + ['USHORT','INT'] + _cast_dict['UINT'] = _cast_dict['USHORT'] + ['SHORT','UINT'] + + _cast_dict['LONG'] = _cast_dict['INT'] + ['LONG'] + _cast_dict['ULONG'] = _cast_dict['UINT'] + ['ULONG'] + + _cast_dict['LONGLONG'] = _cast_dict['LONG'] + ['LONGLONG'] + _cast_dict['ULONGLONG'] = _cast_dict['ULONG'] + ['ULONGLONG'] + + _cast_dict['FLOAT'] = _cast_dict['SHORT'] + ['USHORT','FLOAT'] + _cast_dict['DOUBLE'] = _cast_dict['INT'] + ['UINT','FLOAT','DOUBLE'] + _cast_dict['LONGDOUBLE'] = _cast_dict['LONG'] + ['ULONG','FLOAT','DOUBLE','LONGDOUBLE'] + + _cast_dict['CFLOAT'] = _cast_dict['FLOAT'] + ['CFLOAT'] + _cast_dict['CDOUBLE'] = _cast_dict['DOUBLE'] + ['CFLOAT','CDOUBLE'] + _cast_dict['CLONGDOUBLE'] = _cast_dict['LONGDOUBLE'] + ['CFLOAT','CDOUBLE','CLONGDOUBLE'] + + + def __new__(cls,name): + if isinstance(name,dtype): + dtype0 = name + name = None + for n,i in typeinfo.items(): + if isinstance(i,tuple) and dtype0.type is i[-1]: + name = n + break + obj = cls._type_cache.get(name.upper(),None) + if obj is not None: + return obj + obj = object.__new__(cls) + obj._init(name) + cls._type_cache[name.upper()] = obj + return obj + + def _init(self,name): + self.NAME = name.upper() + self.type_num = getattr(wrap,'PyArray_'+self.NAME) + assert_equal(self.type_num,typeinfo[self.NAME][1]) + self.dtype = typeinfo[self.NAME][-1] + self.elsize = typeinfo[self.NAME][2] / 8 + self.dtypechar = typeinfo[self.NAME][0] + + def cast_types(self): + return map(self.__class__,self._cast_dict[self.NAME]) + + def all_types(self): + return map(self.__class__,self._type_names) + + def smaller_types(self): + bits = typeinfo[self.NAME][3] + types = [] + for name in self._type_names: + if typeinfo[name][3]<bits: + types.append(Type(name)) + return types + + def equal_types(self): + bits = typeinfo[self.NAME][3] + types = [] + for name in self._type_names: + if name==self.NAME: continue + if typeinfo[name][3]==bits: + types.append(Type(name)) + return types + + def larger_types(self): + bits = typeinfo[self.NAME][3] + types = [] + for name in self._type_names: + if typeinfo[name][3]>bits: + types.append(Type(name)) + return types + +class Array: + def __init__(self,typ,dims,intent,obj): + self.type = typ + self.dims = dims + self.intent = intent + self.obj_copy = copy.deepcopy(obj) + self.obj = obj + + # arr.dtypechar may be different from typ.dtypechar + self.arr = wrap.call(typ.type_num,dims,intent.flags,obj) + + self.arr_attr = wrap.array_attrs(self.arr) + + if len(dims)>1: + if self.intent.is_intent('c'): + assert intent.flags & wrap.F2PY_INTENT_C + assert not self.arr.flags['FORTRAN'],`self.arr.flags,obj.flags` + assert self.arr.flags['CONTIGUOUS'] + assert not self.arr_attr[6] & wrap.FORTRAN + else: + assert not intent.flags & wrap.F2PY_INTENT_C + assert self.arr.flags['FORTRAN'] + assert not self.arr.flags['CONTIGUOUS'] + assert self.arr_attr[6] & wrap.FORTRAN + + if obj is None: + self.pyarr = None + self.pyarr_attr = None + return + + if intent.is_intent('cache'): + assert isinstance(obj,ndarray),`type(obj)` + self.pyarr = array(obj).reshape(*dims) + + else: + self.pyarr = array(array(obj, + dtype = typ.dtypechar).reshape(*dims), + fortran=not self.intent.is_intent('c')) + assert self.pyarr.dtype.char==typ.dtypechar,\ + `self.pyarr.dtype.char,typ.dtypechar` + assert self.pyarr.flags['OWNDATA'] + self.pyarr_attr = wrap.array_attrs(self.pyarr) + + if len(dims)>1: + if self.intent.is_intent('c'): + assert not self.pyarr.flags['FORTRAN'] + assert self.pyarr.flags['CONTIGUOUS'] + assert not self.pyarr_attr[6] & wrap.FORTRAN + else: + assert self.pyarr.flags['FORTRAN'] + assert not self.pyarr.flags['CONTIGUOUS'] + assert self.pyarr_attr[6] & wrap.FORTRAN + + + assert self.arr_attr[1]==self.pyarr_attr[1] # nd + assert self.arr_attr[2]==self.pyarr_attr[2] # dimensions + if self.arr_attr[1]<=1: + assert self.arr_attr[3]==self.pyarr_attr[3],\ + `self.arr_attr[3],self.pyarr_attr[3],self.arr.tostring(),self.pyarr.tostring()` # strides + assert self.arr_attr[5][-2:]==self.pyarr_attr[5][-2:],\ + `self.arr_attr[5],self.pyarr_attr[5]` # descr + assert self.arr_attr[6]==self.pyarr_attr[6],\ + `self.arr_attr[6],self.pyarr_attr[6],flags2names(0*self.arr_attr[6]-self.pyarr_attr[6]),flags2names(self.arr_attr[6]),intent` # flags + + if intent.is_intent('cache'): + assert self.arr_attr[5][3]>=self.type.elsize,\ + `self.arr_attr[5][3],self.type.elsize` + else: + assert self.arr_attr[5][3]==self.type.elsize,\ + `self.arr_attr[5][3],self.type.elsize` + assert self.arr_equal(self.pyarr,self.arr) + + if isinstance(self.obj,ndarray): + if typ.elsize==Type(obj.dtype).elsize: + if not intent.is_intent('copy') and self.arr_attr[1]<=1: + assert self.has_shared_memory() + + def arr_equal(self,arr1,arr2): + if arr1.shape != arr2.shape: + return False + s = arr1==arr2 + return alltrue(s.flatten()) + + def __str__(self): + return str(self.arr) + + def has_shared_memory(self): + """Check that created array shares data with input array. + """ + if self.obj is self.arr: + return True + if not isinstance(self.obj,ndarray): + return False + obj_attr = wrap.array_attrs(self.obj) + return obj_attr[0]==self.arr_attr[0] + +################################################## + +class test_intent(unittest.TestCase): + def check_in_out(self): + assert_equal(str(intent.in_.out),'intent(in,out)') + assert intent.in_.c.is_intent('c') + assert not intent.in_.c.is_intent_exact('c') + assert intent.in_.c.is_intent_exact('c','in') + assert intent.in_.c.is_intent_exact('in','c') + assert not intent.in_.is_intent('c') + +class _test_shared_memory: + num2seq = [1,2] + num23seq = [[1,2,3],[4,5,6]] + def check_in_from_2seq(self): + a = self.array([2],intent.in_,self.num2seq) + assert not a.has_shared_memory() + + def check_in_from_2casttype(self): + for t in self.type.cast_types(): + obj = array(self.num2seq,dtype=t.dtype) + a = self.array([len(self.num2seq)],intent.in_,obj) + if t.elsize==self.type.elsize: + assert a.has_shared_memory(),`self.type.dtype,t.dtype` + else: + assert not a.has_shared_memory(),`t.dtype` + + def check_inout_2seq(self): + obj = array(self.num2seq,dtype=self.type.dtype) + a = self.array([len(self.num2seq)],intent.inout,obj) + assert a.has_shared_memory() + + try: + a = self.array([2],intent.in_.inout,self.num2seq) + except TypeError,msg: + if not str(msg).startswith('failed to initialize intent(inout|inplace|cache) array'): + raise + else: + raise SystemError,'intent(inout) should have failed on sequence' + + def check_f_inout_23seq(self): + obj = array(self.num23seq,dtype=self.type.dtype,fortran=1) + shape = (len(self.num23seq),len(self.num23seq[0])) + a = self.array(shape,intent.in_.inout,obj) + assert a.has_shared_memory() + + obj = array(self.num23seq,dtype=self.type.dtype,fortran=0) + shape = (len(self.num23seq),len(self.num23seq[0])) + try: + a = self.array(shape,intent.in_.inout,obj) + except ValueError,msg: + if not str(msg).startswith('failed to initialize intent(inout) array'): + raise + else: + raise SystemError,'intent(inout) should have failed on improper array' + + def check_c_inout_23seq(self): + obj = array(self.num23seq,dtype=self.type.dtype) + shape = (len(self.num23seq),len(self.num23seq[0])) + a = self.array(shape,intent.in_.c.inout,obj) + assert a.has_shared_memory() + + def check_in_copy_from_2casttype(self): + for t in self.type.cast_types(): + obj = array(self.num2seq,dtype=t.dtype) + a = self.array([len(self.num2seq)],intent.in_.copy,obj) + assert not a.has_shared_memory(),`t.dtype` + + def check_c_in_from_23seq(self): + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_,self.num23seq) + assert not a.has_shared_memory() + + def check_in_from_23casttype(self): + for t in self.type.cast_types(): + obj = array(self.num23seq,dtype=t.dtype) + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_,obj) + assert not a.has_shared_memory(),`t.dtype` + + def check_f_in_from_23casttype(self): + for t in self.type.cast_types(): + obj = array(self.num23seq,dtype=t.dtype,fortran=1) + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_,obj) + if t.elsize==self.type.elsize: + assert a.has_shared_memory(),`t.dtype` + else: + assert not a.has_shared_memory(),`t.dtype` + + def check_c_in_from_23casttype(self): + for t in self.type.cast_types(): + obj = array(self.num23seq,dtype=t.dtype) + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_.c,obj) + if t.elsize==self.type.elsize: + assert a.has_shared_memory(),`t.dtype` + else: + assert not a.has_shared_memory(),`t.dtype` + + def check_f_copy_in_from_23casttype(self): + for t in self.type.cast_types(): + obj = array(self.num23seq,dtype=t.dtype,fortran=1) + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_.copy,obj) + assert not a.has_shared_memory(),`t.dtype` + + def check_c_copy_in_from_23casttype(self): + for t in self.type.cast_types(): + obj = array(self.num23seq,dtype=t.dtype) + a = self.array([len(self.num23seq),len(self.num23seq[0])], + intent.in_.c.copy,obj) + assert not a.has_shared_memory(),`t.dtype` + + def check_in_cache_from_2casttype(self): + for t in self.type.all_types(): + if t.elsize != self.type.elsize: + continue + obj = array(self.num2seq,dtype=t.dtype) + shape = (len(self.num2seq),) + a = self.array(shape,intent.in_.c.cache,obj) + assert a.has_shared_memory(),`t.dtype` + + a = self.array(shape,intent.in_.cache,obj) + assert a.has_shared_memory(),`t.dtype` + + obj = array(self.num2seq,dtype=t.dtype,fortran=1) + a = self.array(shape,intent.in_.c.cache,obj) + assert a.has_shared_memory(),`t.dtype` + + a = self.array(shape,intent.in_.cache,obj) + assert a.has_shared_memory(),`t.dtype` + + try: + a = self.array(shape,intent.in_.cache,obj[::-1]) + except ValueError,msg: + if not str(msg).startswith('failed to initialize intent(cache) array'): + raise + else: + raise SystemError,'intent(cache) should have failed on multisegmented array' + def check_in_cache_from_2casttype_failure(self): + for t in self.type.all_types(): + if t.elsize >= self.type.elsize: + continue + obj = array(self.num2seq,dtype=t.dtype) + shape = (len(self.num2seq),) + try: + a = self.array(shape,intent.in_.cache,obj) + except ValueError,msg: + if not str(msg).startswith('failed to initialize intent(cache) array'): + raise + else: + raise SystemError,'intent(cache) should have failed on smaller array' + + def check_cache_hidden(self): + shape = (2,) + a = self.array(shape,intent.cache.hide,None) + assert a.arr.shape==shape + + shape = (2,3) + a = self.array(shape,intent.cache.hide,None) + assert a.arr.shape==shape + + shape = (-1,3) + try: + a = self.array(shape,intent.cache.hide,None) + except ValueError,msg: + if not str(msg).startswith('failed to create intent(cache|hide)|optional array'): + raise + else: + raise SystemError,'intent(cache) should have failed on undefined dimensions' + + def check_hidden(self): + shape = (2,) + a = self.array(shape,intent.hide,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + + shape = (2,3) + a = self.array(shape,intent.hide,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + assert a.arr.flags['FORTRAN'] and not a.arr.flags['CONTIGUOUS'] + + shape = (2,3) + a = self.array(shape,intent.c.hide,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + assert not a.arr.flags['FORTRAN'] and a.arr.flags['CONTIGUOUS'] + + shape = (-1,3) + try: + a = self.array(shape,intent.hide,None) + except ValueError,msg: + if not str(msg).startswith('failed to create intent(cache|hide)|optional array'): + raise + else: + raise SystemError,'intent(hide) should have failed on undefined dimensions' + + def check_optional_none(self): + shape = (2,) + a = self.array(shape,intent.optional,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + + shape = (2,3) + a = self.array(shape,intent.optional,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + assert a.arr.flags['FORTRAN'] and not a.arr.flags['CONTIGUOUS'] + + shape = (2,3) + a = self.array(shape,intent.c.optional,None) + assert a.arr.shape==shape + assert a.arr_equal(a.arr,zeros(shape,dtype=self.type.dtype)) + assert not a.arr.flags['FORTRAN'] and a.arr.flags['CONTIGUOUS'] + + def check_optional_from_2seq(self): + obj = self.num2seq + shape = (len(obj),) + a = self.array(shape,intent.optional,obj) + assert a.arr.shape==shape + assert not a.has_shared_memory() + + def check_optional_from_23seq(self): + obj = self.num23seq + shape = (len(obj),len(obj[0])) + a = self.array(shape,intent.optional,obj) + assert a.arr.shape==shape + assert not a.has_shared_memory() + + a = self.array(shape,intent.optional.c,obj) + assert a.arr.shape==shape + assert not a.has_shared_memory() + + def check_inplace(self): + obj = array(self.num23seq,dtype=self.type.dtype) + assert not obj.flags['FORTRAN'] and obj.flags['CONTIGUOUS'] + shape = obj.shape + a = self.array(shape,intent.inplace,obj) + assert obj[1][2]==a.arr[1][2],`obj,a.arr` + a.arr[1][2]=54 + assert obj[1][2]==a.arr[1][2]==array(54,dtype=self.type.dtype),`obj,a.arr` + assert a.arr is obj + assert obj.flags['FORTRAN'] # obj attributes are changed inplace! + assert not obj.flags['CONTIGUOUS'] + + def check_inplace_from_casttype(self): + for t in self.type.cast_types(): + if t is self.type: + continue + obj = array(self.num23seq,dtype=t.dtype) + assert obj.dtype.type==t.dtype + assert obj.dtype.type is not self.type.dtype + assert not obj.flags['FORTRAN'] and obj.flags['CONTIGUOUS'] + shape = obj.shape + a = self.array(shape,intent.inplace,obj) + assert obj[1][2]==a.arr[1][2],`obj,a.arr` + a.arr[1][2]=54 + assert obj[1][2]==a.arr[1][2]==array(54,dtype=self.type.dtype),`obj,a.arr` + assert a.arr is obj + assert obj.flags['FORTRAN'] # obj attributes are changed inplace! + assert not obj.flags['CONTIGUOUS'] + assert obj.dtype.type is self.type.dtype # obj type is changed inplace! + +for t in Type._type_names: + exec '''\ +class test_%s_gen(unittest.TestCase, + _test_shared_memory + ): + type = Type(%r) + array = lambda self,dims,intent,obj: Array(Type(%r),dims,intent,obj) +''' % (t,t,t) + +if __name__ == "__main__": + NumpyTest().run() diff --git a/numpy/f2py/tests/array_from_pyobj/wrapmodule.c b/numpy/f2py/tests/array_from_pyobj/wrapmodule.c new file mode 100644 index 000000000..38a794a7d --- /dev/null +++ b/numpy/f2py/tests/array_from_pyobj/wrapmodule.c @@ -0,0 +1,196 @@ +/* File: wrapmodule.c + * This file is auto-generated with f2py (version:2_1330). + * Hand edited by Pearu. + * f2py is a Fortran to Python Interface Generator (FPIG), Second Edition, + * written by Pearu Peterson <pearu@cens.ioc.ee>. + * See http://cens.ioc.ee/projects/f2py2e/ + * Generation date: Fri Oct 21 22:41:12 2005 + * $Revision:$ + * $Date:$ + * Do not edit this file directly unless you know what you are doing!!! + */ +#ifdef __cplusplus +extern "C" { +#endif + +/*********************** See f2py2e/cfuncs.py: includes ***********************/ +#include "Python.h" +#include "fortranobject.h" +#include <math.h> + +static PyObject *wrap_error; +static PyObject *wrap_module; + +/************************************ call ************************************/ +static char doc_f2py_rout_wrap_call[] = "\ +Function signature:\n\ + arr = call(type_num,dims,intent,obj)\n\ +Required arguments:\n" +" type_num : input int\n" +" dims : input int-sequence\n" +" intent : input int\n" +" obj : input python object\n" +"Return objects:\n" +" arr : array"; +static PyObject *f2py_rout_wrap_call(PyObject *capi_self, + PyObject *capi_args) { + PyObject * volatile capi_buildvalue = NULL; + int type_num = 0; + intp *dims = NULL; + PyObject *dims_capi = Py_None; + int rank = 0; + int intent = 0; + PyArrayObject *capi_arr_tmp = NULL; + PyObject *arr_capi = Py_None; + int i; + + if (!PyArg_ParseTuple(capi_args,"iOiO|:wrap.call",\ + &type_num,&dims_capi,&intent,&arr_capi)) + return NULL; + rank = PySequence_Length(dims_capi); + dims = malloc(rank*sizeof(intp)); + for (i=0;i<rank;++i) + dims[i] = (intp)PyInt_AsLong(PySequence_GetItem(dims_capi,i)); + + capi_arr_tmp = array_from_pyobj(type_num,dims,rank,intent|F2PY_INTENT_OUT,arr_capi); + if (capi_arr_tmp == NULL) + return NULL; + capi_buildvalue = Py_BuildValue("N",capi_arr_tmp); + free(dims); + return capi_buildvalue; +} + +static char doc_f2py_rout_wrap_attrs[] = "\ +Function signature:\n\ + arr = array_attrs(arr)\n\ +Required arguments:\n" +" arr : input array object\n" +"Return objects:\n" +" data : data address in hex\n" +" nd : int\n" +" dimensions : tuple\n" +" strides : tuple\n" +" base : python object\n" +" (kind,type,type_num,elsize,alignment) : 4-tuple\n" +" flags : int\n" +" itemsize : int\n" +; +static PyObject *f2py_rout_wrap_attrs(PyObject *capi_self, + PyObject *capi_args) { + PyObject *arr_capi = Py_None; + PyArrayObject *arr = NULL; + PyObject *dimensions = NULL; + PyObject *strides = NULL; + char s[100]; + int i; + memset(s,0,100*sizeof(char)); + if (!PyArg_ParseTuple(capi_args,"O!|:wrap.attrs", + &PyArray_Type,&arr_capi)) + return NULL; + arr = (PyArrayObject *)arr_capi; + sprintf(s,"%p",arr->data); + dimensions = PyTuple_New(arr->nd); + strides = PyTuple_New(arr->nd); + for (i=0;i<arr->nd;++i) { + PyTuple_SetItem(dimensions,i,PyInt_FromLong(arr->dimensions[i])); + PyTuple_SetItem(strides,i,PyInt_FromLong(arr->strides[i])); + } + return Py_BuildValue("siOOO(cciii)ii",s,arr->nd, + dimensions,strides, + (arr->base==NULL?Py_None:arr->base), + arr->descr->kind, + arr->descr->type, + arr->descr->type_num, + arr->descr->elsize, + arr->descr->alignment, + arr->flags, + PyArray_ITEMSIZE(arr)); +} + +static PyMethodDef f2py_module_methods[] = { + + {"call",f2py_rout_wrap_call,METH_VARARGS,doc_f2py_rout_wrap_call}, + {"array_attrs",f2py_rout_wrap_attrs,METH_VARARGS,doc_f2py_rout_wrap_attrs}, + {NULL,NULL} +}; + +PyMODINIT_FUNC initwrap(void) { + PyObject *m,*d, *s; + m = wrap_module = Py_InitModule("wrap", f2py_module_methods); + PyFortran_Type.ob_type = &PyType_Type; + import_array(); + if (PyErr_Occurred()) + Py_FatalError("can't initialize module wrap (failed to import numpy)"); + d = PyModule_GetDict(m); + s = PyString_FromString("This module 'wrap' is auto-generated with f2py (version:2_1330).\nFunctions:\n" +" arr = call(type_num,dims,intent,obj)\n" +"."); + PyDict_SetItemString(d, "__doc__", s); + wrap_error = PyErr_NewException ("wrap.error", NULL, NULL); + Py_DECREF(s); + PyDict_SetItemString(d, "F2PY_INTENT_IN", PyInt_FromLong(F2PY_INTENT_IN)); + PyDict_SetItemString(d, "F2PY_INTENT_INOUT", PyInt_FromLong(F2PY_INTENT_INOUT)); + PyDict_SetItemString(d, "F2PY_INTENT_OUT", PyInt_FromLong(F2PY_INTENT_OUT)); + PyDict_SetItemString(d, "F2PY_INTENT_HIDE", PyInt_FromLong(F2PY_INTENT_HIDE)); + PyDict_SetItemString(d, "F2PY_INTENT_CACHE", PyInt_FromLong(F2PY_INTENT_CACHE)); + PyDict_SetItemString(d, "F2PY_INTENT_COPY", PyInt_FromLong(F2PY_INTENT_COPY)); + PyDict_SetItemString(d, "F2PY_INTENT_C", PyInt_FromLong(F2PY_INTENT_C)); + PyDict_SetItemString(d, "F2PY_OPTIONAL", PyInt_FromLong(F2PY_OPTIONAL)); + PyDict_SetItemString(d, "F2PY_INTENT_INPLACE", PyInt_FromLong(F2PY_INTENT_INPLACE)); + PyDict_SetItemString(d, "PyArray_BOOL", PyInt_FromLong(PyArray_BOOL)); + PyDict_SetItemString(d, "PyArray_BYTE", PyInt_FromLong(PyArray_BYTE)); + PyDict_SetItemString(d, "PyArray_UBYTE", PyInt_FromLong(PyArray_UBYTE)); + PyDict_SetItemString(d, "PyArray_SHORT", PyInt_FromLong(PyArray_SHORT)); + PyDict_SetItemString(d, "PyArray_USHORT", PyInt_FromLong(PyArray_USHORT)); + PyDict_SetItemString(d, "PyArray_INT", PyInt_FromLong(PyArray_INT)); + PyDict_SetItemString(d, "PyArray_UINT", PyInt_FromLong(PyArray_UINT)); + PyDict_SetItemString(d, "PyArray_INTP", PyInt_FromLong(PyArray_INTP)); + PyDict_SetItemString(d, "PyArray_UINTP", PyInt_FromLong(PyArray_UINTP)); + PyDict_SetItemString(d, "PyArray_LONG", PyInt_FromLong(PyArray_LONG)); + PyDict_SetItemString(d, "PyArray_ULONG", PyInt_FromLong(PyArray_ULONG)); + PyDict_SetItemString(d, "PyArray_LONGLONG", PyInt_FromLong(PyArray_LONGLONG)); + PyDict_SetItemString(d, "PyArray_ULONGLONG", PyInt_FromLong(PyArray_ULONGLONG)); + PyDict_SetItemString(d, "PyArray_FLOAT", PyInt_FromLong(PyArray_FLOAT)); + PyDict_SetItemString(d, "PyArray_DOUBLE", PyInt_FromLong(PyArray_DOUBLE)); + PyDict_SetItemString(d, "PyArray_LONGDOUBLE", PyInt_FromLong(PyArray_LONGDOUBLE)); + PyDict_SetItemString(d, "PyArray_CFLOAT", PyInt_FromLong(PyArray_CFLOAT)); + PyDict_SetItemString(d, "PyArray_CDOUBLE", PyInt_FromLong(PyArray_CDOUBLE)); + PyDict_SetItemString(d, "PyArray_CLONGDOUBLE", PyInt_FromLong(PyArray_CLONGDOUBLE)); + PyDict_SetItemString(d, "PyArray_OBJECT", PyInt_FromLong(PyArray_OBJECT)); + PyDict_SetItemString(d, "PyArray_STRING", PyInt_FromLong(PyArray_STRING)); + PyDict_SetItemString(d, "PyArray_UNICODE", PyInt_FromLong(PyArray_UNICODE)); + PyDict_SetItemString(d, "PyArray_VOID", PyInt_FromLong(PyArray_VOID)); + PyDict_SetItemString(d, "PyArray_NTYPES", PyInt_FromLong(PyArray_NTYPES)); + PyDict_SetItemString(d, "PyArray_NOTYPE", PyInt_FromLong(PyArray_NOTYPE)); + PyDict_SetItemString(d, "PyArray_UDERDEF", PyInt_FromLong(PyArray_USERDEF)); + + PyDict_SetItemString(d, "CONTIGUOUS", PyInt_FromLong(CONTIGUOUS)); + PyDict_SetItemString(d, "FORTRAN", PyInt_FromLong(FORTRAN)); + PyDict_SetItemString(d, "OWNDATA", PyInt_FromLong(OWNDATA)); + PyDict_SetItemString(d, "FORCECAST", PyInt_FromLong(FORCECAST)); + PyDict_SetItemString(d, "ENSURECOPY", PyInt_FromLong(ENSURECOPY)); + PyDict_SetItemString(d, "ENSUREARRAY", PyInt_FromLong(ENSUREARRAY)); + PyDict_SetItemString(d, "ALIGNED", PyInt_FromLong(ALIGNED)); + PyDict_SetItemString(d, "WRITEABLE", PyInt_FromLong(WRITEABLE)); + PyDict_SetItemString(d, "UPDATEIFCOPY", PyInt_FromLong(UPDATEIFCOPY)); + + PyDict_SetItemString(d, "BEHAVED", PyInt_FromLong(NPY_BEHAVED)); + PyDict_SetItemString(d, "BEHAVED_NS", PyInt_FromLong(NPY_BEHAVED_NS)); + PyDict_SetItemString(d, "CARRAY", PyInt_FromLong(NPY_CARRAY)); + PyDict_SetItemString(d, "FARRAY", PyInt_FromLong(NPY_FARRAY)); + PyDict_SetItemString(d, "CARRAY_RO", PyInt_FromLong(NPY_CARRAY_RO)); + PyDict_SetItemString(d, "FARRAY_RO", PyInt_FromLong(NPY_FARRAY_RO)); + PyDict_SetItemString(d, "DEFAULT", PyInt_FromLong(NPY_DEFAULT)); + PyDict_SetItemString(d, "UPDATE_ALL", PyInt_FromLong(NPY_UPDATE_ALL)); + + if (PyErr_Occurred()) + Py_FatalError("can't initialize module wrap"); + +#ifdef F2PY_REPORT_ATEXIT + on_exit(f2py_report_on_exit,(void*)"array_from_pyobj.wrap.call"); +#endif + +} +#ifdef __cplusplus +} +#endif diff --git a/numpy/f2py/tests/c/return_real.py b/numpy/f2py/tests/c/return_real.py new file mode 100644 index 000000000..62dbd2f74 --- /dev/null +++ b/numpy/f2py/tests/c/return_real.py @@ -0,0 +1,107 @@ +__usage__ = """ +Run: + python return_real.py [<f2py options>] +Examples: + python return_real.py --fcompiler=Gnu --no-wrap-functions + python return_real.py --quiet +""" + +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import c_ext_return_real + except ImportError: + assert not f2py2e.compile('''\ +python module c_ext_return_real +usercode \'\'\' +float t4(float value) { return value; } +void s4(float *t4, float value) { *t4 = value; } +double t8(double value) { return value; } +void s8(double *t8, double value) { *t8 = value; } +\'\'\' +interface + function t4(value) + real*4 intent(c) :: t4,value + end + function t8(value) + real*8 intent(c) :: t8,value + end + subroutine s4(t4,value) + intent(c) s4 + real*4 intent(out) :: t4 + real*4 intent(c) :: value + end + subroutine s8(t8,value) + intent(c) s8 + real*8 intent(out) :: t8 + real*8 intent(c) :: value + end +end interface +end python module c_ext_return_real +''','c_ext_return_real',f2py_opts,source_fn='c_ret_real.pyf') + + from c_ext_return_real import t4,t8,s4,s8 + test_functions = [t4,t8,s4,s8] + return test_functions + +def runtest(t): + import sys + if t.__doc__.split()[0] in ['t0','t4','s0','s4']: + err = 1e-5 + else: + err = 0.0 + assert abs(t(234)-234.0)<=err + assert abs(t(234.6)-234.6)<=err + assert abs(t(234l)-234.0)<=err + if sys.version[:3]<'2.3': + assert abs(t(234.6+3j)-234.6)<=err + assert abs(t('234')-234)<=err + assert abs(t('234.6')-234.6)<=err + assert abs(t(-234)+234)<=err + assert abs(t([234])-234)<=err + assert abs(t((234,))-234.)<=err + assert abs(t(array(234))-234.)<=err + assert abs(t(array([234]))-234.)<=err + assert abs(t(array([[234]]))-234.)<=err + assert abs(t(array([234],'1'))+22)<=err + assert abs(t(array([234],'s'))-234.)<=err + assert abs(t(array([234],'i'))-234.)<=err + assert abs(t(array([234],'l'))-234.)<=err + assert abs(t(array([234],'b'))-234.)<=err + assert abs(t(array([234],'f'))-234.)<=err + assert abs(t(array([234],'d'))-234.)<=err + if sys.version[:3]<'2.3': + assert abs(t(array([234+3j],'F'))-234.)<=err + assert abs(t(array([234],'D'))-234.)<=err + if t.__doc__.split()[0] in ['t0','t4','s0','s4']: + assert t(1e200)==t(1e300) # inf + + try: raise RuntimeError,`t(array([234],'c'))` + except ValueError: pass + try: raise RuntimeError,`t('abc')` + except ValueError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + try: + try: raise RuntimeError,`t(10l**400)` + except OverflowError: pass + except RuntimeError: + r = t(10l**400); assert `r` in ['inf','Infinity'],`r` + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f77/callback.py b/numpy/f2py/tests/f77/callback.py new file mode 100644 index 000000000..bfe4eb547 --- /dev/null +++ b/numpy/f2py/tests/f77/callback.py @@ -0,0 +1,98 @@ +__usage__ = """ +Run: + python callback.py [<f2py options>] +Examples: + python callback.py --fcompiler=Gnu --no-wrap-functions + python callback.py --quiet +""" + +import f2py2e +import math +import sys +from Numeric import array + +def build(f2py_opts): + try: + import f77_ext_callback + except ImportError: + assert not f2py2e.compile('''\ + subroutine t(fun,a) + integer a +cf2py intent(out) a + external fun + call fun(a) + end + + subroutine func(a) +cf2py intent(in,out) a + integer a + a = a + 11 + end + + subroutine func0(a) +cf2py intent(out) a + integer a + a = 11 + end + + subroutine t2(a) +cf2py intent(callback) fun + integer a +cf2py intent(out) a + external fun + call fun(a) + end + +''','f77_ext_callback',f2py_opts,source_fn='f77_callback.f') + + from f77_ext_callback import t,t2 + test_functions = [t,t2] + return test_functions + +def runtest(t): + r = t(lambda : 4) + assert r==4,`r` + r = t(lambda a:5,fun_extra_args=(6,)) + assert r==5,`r` + r = t(lambda a:a,fun_extra_args=(6,)) + assert r==6,`r` + r = t(lambda a:5+a,fun_extra_args=(7,)) + assert r==12,`r` + if sys.version[:3]>='2.3': + r = t(lambda a:math.degrees(a),fun_extra_args=(math.pi,)) + assert r==180,`r` + r = t(math.degrees,fun_extra_args=(math.pi,)) + assert r==180,`r` + from f77_ext_callback import func,func0 + r = t(func,fun_extra_args=(6,)) + assert r==17,`r` + r = t(func0) + assert r==11,`r` + r = t(func0._cpointer) + assert r==11,`r` + class A: + def __call__(self): + return 7 + def mth(self): + return 9 + a = A() + r = t(a) + assert r==7,`r` + r = t(a.mth) + assert r==9,`r` + +if __name__=='__main__': + #import libwadpy + status = 1 + try: + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' + status = 0 + finally: + if status: + print '*'*20 + print 'Running f2py2e.diagnose' + import f2py2e.diagnose + f2py2e.diagnose.run() diff --git a/numpy/f2py/tests/f77/return_character.py b/numpy/f2py/tests/f77/return_character.py new file mode 100644 index 000000000..b44b6ee70 --- /dev/null +++ b/numpy/f2py/tests/f77/return_character.py @@ -0,0 +1,99 @@ +__usage__ = """ +Run: + python return_character.py [<f2py options>] +Examples: + python return_character.py --fcompiler=Gnu --no-wrap-functions + python return_character.py --quiet +""" + +import sys +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f77_ext_return_character + except ImportError: + assert not f2py2e.compile('''\ + function t0(value) + character value + character t0 + t0 = value + end + function t1(value) + character*1 value + character*1 t1 + t1 = value + end + function t5(value) + character*5 value + character*5 t5 + t5 = value + end + function ts(value) + character*(*) value + character*(*) ts + ts = value + end + + subroutine s0(t0,value) + character value + character t0 +cf2py intent(out) t0 + t0 = value + end + subroutine s1(t1,value) + character*1 value + character*1 t1 +cf2py intent(out) t1 + t1 = value + end + subroutine s5(t5,value) + character*5 value + character*5 t5 +cf2py intent(out) t5 + t5 = value + end + subroutine ss(ts,value) + character*(*) value + character*10 ts +cf2py intent(out) ts + ts = value + end +''','f77_ext_return_character',f2py_opts,source_fn='f77_ret_char.f') + + from f77_ext_return_character import t0,t1,t5,s0,s1,s5,ss + test_functions = [t0,t1,t5,s0,s1,s5,ss] + if sys.platform!='win32': # this is acctually compiler dependent case + from f77_ext_return_character import ts + test_functions.append(ts) + + return test_functions + +def runtest(t): + tname = t.__doc__.split()[0] + if tname in ['t0','t1','s0','s1']: + assert t(23)=='2' + r = t('ab');assert r=='a',`r` + r = t(array('ab'));assert r=='a',`r` + r = t(array(77,'1'));assert r=='M',`r` + try: raise RuntimeError,`t(array([77,87]))` + except ValueError: pass + try: raise RuntimeError,`t(array(77))` + except ValueError: pass + elif tname in ['ts','ss']: + assert t(23)=='23 ',`t(23)` + assert t('123456789abcdef')=='123456789a' + elif tname in ['t5','s5']: + assert t(23)=='23 ',`t(23)` + assert t('ab')=='ab ',`t('ab')` + assert t('123456789abcdef')=='12345' + else: + raise NotImplementedError + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f77/return_complex.py b/numpy/f2py/tests/f77/return_complex.py new file mode 100644 index 000000000..e182902b3 --- /dev/null +++ b/numpy/f2py/tests/f77/return_complex.py @@ -0,0 +1,124 @@ +__usage__ = """ +Run: + python return_complex.py [<f2py options>] +Examples: + python return_complex.py --fcompiler=Gnu --no-wrap-functions + python return_complex.py --quiet +""" + +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f77_ext_return_complex + except ImportError: + assert not f2py2e.compile('''\ + function t0(value) + complex value + complex t0 + t0 = value + end + function t8(value) + complex*8 value + complex*8 t8 + t8 = value + end + function t16(value) + complex*16 value + complex*16 t16 + t16 = value + end + function td(value) + double complex value + double complex td + td = value + end + + subroutine s0(t0,value) + complex value + complex t0 +cf2py intent(out) t0 + t0 = value + end + subroutine s8(t8,value) + complex*8 value + complex*8 t8 +cf2py intent(out) t8 + t8 = value + end + subroutine s16(t16,value) + complex*16 value + complex*16 t16 +cf2py intent(out) t16 + t16 = value + end + subroutine sd(td,value) + double complex value + double complex td +cf2py intent(out) td + td = value + end +''','f77_ext_return_complex',f2py_opts) + + from f77_ext_return_complex import t0,t8,t16,td,s0,s8,s16,sd + test_functions = [t0,t8,t16,td,s0,s8,s16,sd] + return test_functions + + +def runtest(t): + tname = t.__doc__.split()[0] + if tname in ['t0','t8','s0','s8']: + err = 1e-5 + else: + err = 0.0 + assert abs(t(234j)-234.0j)<=err + assert abs(t(234.6)-234.6)<=err + assert abs(t(234l)-234.0)<=err + assert abs(t(234.6+3j)-(234.6+3j))<=err + #assert abs(t('234')-234.)<=err + #assert abs(t('234.6')-234.6)<=err + assert abs(t(-234)+234.)<=err + assert abs(t([234])-234.)<=err + assert abs(t((234,))-234.)<=err + assert abs(t(array(234))-234.)<=err + assert abs(t(array(23+4j,'F'))-(23+4j))<=err + assert abs(t(array([234]))-234.)<=err + assert abs(t(array([[234]]))-234.)<=err + assert abs(t(array([234],'1'))+22.)<=err + assert abs(t(array([234],'s'))-234.)<=err + assert abs(t(array([234],'i'))-234.)<=err + assert abs(t(array([234],'l'))-234.)<=err + assert abs(t(array([234],'b'))-234.)<=err + assert abs(t(array([234],'f'))-234.)<=err + assert abs(t(array([234],'d'))-234.)<=err + assert abs(t(array([234+3j],'F'))-(234+3j))<=err + assert abs(t(array([234],'D'))-234.)<=err + + try: raise RuntimeError,`t(array([234],'c'))` + except TypeError: pass + try: raise RuntimeError,`t('abc')` + except TypeError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + try: + try: raise RuntimeError,`t(10l**400)` + except OverflowError: pass + except RuntimeError: + r = t(10l**400); assert `r` in ['(inf+0j)','(Infinity+0j)'],`r` + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f77/return_integer.py b/numpy/f2py/tests/f77/return_integer.py new file mode 100644 index 000000000..fe9e70fda --- /dev/null +++ b/numpy/f2py/tests/f77/return_integer.py @@ -0,0 +1,147 @@ +__usage__ = """ +Run: + python return_integer.py [<f2py options>] +Examples: + python return_integer.py --fcompiler=Gnu --no-wrap-functions + python return_integer.py --quiet +""" + +import numpy.f2py as f2py2e +from numpy import array + +def build(f2py_opts): + try: + import f77_ext_return_integer + except ImportError: + assert not f2py2e.compile('''\ + function t0(value) + integer value + integer t0 + t0 = value + end + function t1(value) + integer*1 value + integer*1 t1 + t1 = value + end + function t2(value) + integer*2 value + integer*2 t2 + t2 = value + end + function t4(value) + integer*4 value + integer*4 t4 + t4 = value + end + function t8(value) + integer*8 value + integer*8 t8 + t8 = value + end + + subroutine s0(t0,value) + integer value + integer t0 +cf2py intent(out) t0 + t0 = value + end + subroutine s1(t1,value) + integer*1 value + integer*1 t1 +cf2py intent(out) t1 + t1 = value + end + subroutine s2(t2,value) + integer*2 value + integer*2 t2 +cf2py intent(out) t2 + t2 = value + end + subroutine s4(t4,value) + integer*4 value + integer*4 t4 +cf2py intent(out) t4 + t4 = value + end + subroutine s8(t8,value) + integer*8 value + integer*8 t8 +cf2py intent(out) t8 + t8 = value + end + +''','f77_ext_return_integer',f2py_opts,source_fn='f77_ret_int.f') + + from f77_ext_return_integer import t0,t1,t2,t4,t8,s0,s1,s2,s4,s8 + test_functions = [t0,t1,t2,t4,t8,s0,s1,s2,s4,s8] + return test_functions + +def runtest(t): + import sys + assert t(123)==123,`t(123)` + assert t(123.6)==123 + assert t(123l)==123 + if sys.version[:3]<'2.3': + assert t(123.6+3j)==123 + assert t('123')==123 + assert t(-123)==-123 + assert t([123])==123 + assert t((123,))==123 + assert t(array(123))==123 + assert t(array([123]))==123 + assert t(array([[123]]))==123 + assert t(array([123],'b'))==123 + assert t(array([123],'h'))==123 + assert t(array([123],'i'))==123 + assert t(array([123],'l'))==123 + assert t(array([123],'B'))==123 + assert t(array([123],'f'))==123 + assert t(array([123],'d'))==123 + if sys.version[:3]<'2.3': + assert t(array([123+3j],'F'))==123 + assert t(array([123],'D'))==123 + + + try: raise RuntimeError,`t(array([123],'c'))` + except ValueError: pass + try: raise RuntimeError,`t('abc')` + except ValueError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + if t.__doc__.split()[0] in ['t8','s8']: + try: raise RuntimeError,`t(100000000000000000000000l)` + except OverflowError: pass + try: raise RuntimeError,`t(10000000011111111111111.23)` + except OverflowError: pass + else: + if sys.version[:3]<'2.3': + try: raise RuntimeError,`t(10000000000000l)` + except OverflowError: pass + try: raise RuntimeError,`t(10000000000.23)` + except OverflowError: pass + +if __name__=='__main__': + #import libwadpy + status = 1 + try: + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' + status = 0 + finally: + if status: + print '*'*20 + print 'Running f2py2e.diagnose' + import numpy.f2py.diagnose as diagnose + #diagnose.run() diff --git a/numpy/f2py/tests/f77/return_logical.py b/numpy/f2py/tests/f77/return_logical.py new file mode 100644 index 000000000..cc5f9cb05 --- /dev/null +++ b/numpy/f2py/tests/f77/return_logical.py @@ -0,0 +1,133 @@ +__usage__ = """ +Run: + python return_logical.py [<f2py options>] +Examples: + python return_logical.py --fcompiler=Gnu --no-wrap-functions + python return_logical.py --quiet +""" + +import f2py2e +from Numeric import array +try: True +except NameError: + True = 1 + False = 0 + +def build(f2py_opts): + try: + import f77_ext_return_logical + except ImportError: + assert not f2py2e.compile('''\ + function t0(value) + logical value + logical t0 + t0 = value + end + function t1(value) + logical*1 value + logical*1 t1 + t1 = value + end + function t2(value) + logical*2 value + logical*2 t2 + t2 = value + end + function t4(value) + logical*4 value + logical*4 t4 + t4 = value + end +c function t8(value) +c logical*8 value +c logical*8 t8 +c t8 = value +c end + + subroutine s0(t0,value) + logical value + logical t0 +cf2py intent(out) t0 + t0 = value + end + subroutine s1(t1,value) + logical*1 value + logical*1 t1 +cf2py intent(out) t1 + t1 = value + end + subroutine s2(t2,value) + logical*2 value + logical*2 t2 +cf2py intent(out) t2 + t2 = value + end + subroutine s4(t4,value) + logical*4 value + logical*4 t4 +cf2py intent(out) t4 + t4 = value + end +c subroutine s8(t8,value) +c logical*8 value +c logical*8 t8 +cf2py intent(out) t8 +c t8 = value +c end +''','f77_ext_return_logical',f2py_opts) + + #from f77_ext_return_logical import t0,t1,t2,t4,t8,s0,s1,s2,s4,s8 + #test_functions = [t0,t1,t2,t4,t8,s0,s1,s2,s4,s8] + from f77_ext_return_logical import t0,t1,t2,t4,s0,s1,s2,s4 + test_functions = [t0,t1,t2,t4,s0,s1,s2,s4] + return test_functions + +def runtest(t): + assert t(True)==1,`t(True)` + assert t(False)==0,`t(False)` + assert t(0)==0 + assert t(None)==0 + assert t(0.0)==0 + assert t(0j)==0 + assert t(1j)==1 + assert t(234)==1 + assert t(234.6)==1 + assert t(234l)==1 + assert t(234.6+3j)==1 + assert t('234')==1 + assert t('aaa')==1 + assert t('')==0 + assert t([])==0 + assert t(())==0 + assert t({})==0 + assert t(t)==1 + assert t(-234)==1 + assert t(10l**100)==1 + assert t([234])==1 + assert t((234,))==1 + assert t(array(234))==1 + assert t(array([234]))==1 + assert t(array([[234]]))==1 + assert t(array([234],'1'))==1 + assert t(array([234],'s'))==1 + assert t(array([234],'i'))==1 + assert t(array([234],'l'))==1 + assert t(array([234],'b'))==1 + assert t(array([234],'f'))==1 + assert t(array([234],'d'))==1 + assert t(array([234+3j],'F'))==1 + assert t(array([234],'D'))==1 + assert t(array(0))==0 + assert t(array([0]))==0 + assert t(array([[0]]))==0 + assert t(array([0j]))==0 + assert t(array([1]))==1 + assert t(array([0,0]))==0 + assert t(array([0,1]))==1 #XXX: is this expected? + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f77/return_real.py b/numpy/f2py/tests/f77/return_real.py new file mode 100644 index 000000000..a751743e9 --- /dev/null +++ b/numpy/f2py/tests/f77/return_real.py @@ -0,0 +1,126 @@ +__usage__ = """ +Run: + python return_real.py [<f2py options>] +Examples: + python return_real.py --fcompiler=Gnu --no-wrap-functions + python return_real.py --quiet +""" + +import numpy.f2py as f2py2e +from numpy import array + +def build(f2py_opts): + try: + import f77_ext_return_real + except ImportError: + assert not f2py2e.compile('''\ + function t0(value) + real value + real t0 + t0 = value + end + function t4(value) + real*4 value + real*4 t4 + t4 = value + end + function t8(value) + real*8 value + real*8 t8 + t8 = value + end + function td(value) + double precision value + double precision td + td = value + end + + subroutine s0(t0,value) + real value + real t0 +cf2py intent(out) t0 + t0 = value + end + subroutine s4(t4,value) + real*4 value + real*4 t4 +cf2py intent(out) t4 + t4 = value + end + subroutine s8(t8,value) + real*8 value + real*8 t8 +cf2py intent(out) t8 + t8 = value + end + subroutine sd(td,value) + double precision value + double precision td +cf2py intent(out) td + td = value + end +''','f77_ext_return_real',f2py_opts,source_fn='f77_ret_real.f') + + from f77_ext_return_real import t0,t4,t8,td,s0,s4,s8,sd + test_functions = [t0,t4,t8,td,s0,s4,s8,sd] + return test_functions + +def runtest(t): + import sys + if t.__doc__.split()[0] in ['t0','t4','s0','s4']: + err = 1e-5 + else: + err = 0.0 + assert abs(t(234)-234.0)<=err + assert abs(t(234.6)-234.6)<=err + assert abs(t(234l)-234.0)<=err + if sys.version[:3]<'2.3': + assert abs(t(234.6+3j)-234.6)<=err + assert abs(t('234')-234)<=err + assert abs(t('234.6')-234.6)<=err + assert abs(t(-234)+234)<=err + assert abs(t([234])-234)<=err + assert abs(t((234,))-234.)<=err + assert abs(t(array(234))-234.)<=err + assert abs(t(array([234]))-234.)<=err + assert abs(t(array([[234]]))-234.)<=err + assert abs(t(array([234],'b'))+22)<=err + assert abs(t(array([234],'h'))-234.)<=err + assert abs(t(array([234],'i'))-234.)<=err + assert abs(t(array([234],'l'))-234.)<=err + assert abs(t(array([234],'B'))-234.)<=err + assert abs(t(array([234],'f'))-234.)<=err + assert abs(t(array([234],'d'))-234.)<=err + if sys.version[:3]<'2.3': + assert abs(t(array([234+3j],'F'))-234.)<=err + assert abs(t(array([234],'D'))-234.)<=err + if t.__doc__.split()[0] in ['t0','t4','s0','s4']: + assert t(1e200)==t(1e300) # inf + + try: raise RuntimeError,`t(array([234],'c'))` + except ValueError: pass + try: raise RuntimeError,`t('abc')` + except ValueError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + try: + try: raise RuntimeError,`t(10l**400)` + except OverflowError: pass + except RuntimeError: + r = t(10l**400); assert `r` in ['inf','Infinity'],`r` + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f90/return_character.py b/numpy/f2py/tests/f90/return_character.py new file mode 100644 index 000000000..1b5515f4d --- /dev/null +++ b/numpy/f2py/tests/f90/return_character.py @@ -0,0 +1,98 @@ +__usage__ = """ +Run: + python return_character.py [<f2py options>] +Examples: + python return_character.py --fcompiler=Gnu --no-wrap-functions + python return_character.py --quiet +""" + +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f90_ext_return_character + except ImportError: + assert not f2py2e.compile('''\ +module f90_return_char + contains + function t0(value) + character :: value + character :: t0 + t0 = value + end function t0 + function t1(value) + character(len=1) :: value + character(len=1) :: t1 + t1 = value + end function t1 + function t5(value) + character(len=5) :: value + character(len=5) :: t5 + t5 = value + end function t5 + function ts(value) + character(len=*) :: value + character(len=10) :: ts + ts = value + end function ts + + subroutine s0(t0,value) + character :: value + character :: t0 +!f2py intent(out) t0 + t0 = value + end subroutine s0 + subroutine s1(t1,value) + character(len=1) :: value + character(len=1) :: t1 +!f2py intent(out) t1 + t1 = value + end subroutine s1 + subroutine s5(t5,value) + character(len=5) :: value + character(len=5) :: t5 +!f2py intent(out) t5 + t5 = value + end subroutine s5 + subroutine ss(ts,value) + character(len=*) :: value + character(len=10) :: ts +!f2py intent(out) ts + ts = value + end subroutine ss +end module f90_return_char +''','f90_ext_return_character',f2py_opts,source_fn='f90_ret_char.f90') + + from f90_ext_return_character import f90_return_char as m + test_functions = [m.t0,m.t1,m.t5,m.ts,m.s0,m.s1,m.s5,m.ss] + return test_functions + + +def runtest(t): + tname = t.__doc__.split()[0] + if tname in ['t0','t1','s0','s1']: + assert t(23)=='2' + r = t('ab');assert r=='a',`r` + r = t(array('ab'));assert r=='a',`r` + r = t(array(77,'1'));assert r=='M',`r` + try: raise RuntimeError,`t(array([77,87]))` + except ValueError: pass + try: raise RuntimeError,`t(array(77))` + except ValueError: pass + elif tname in ['ts','ss']: + assert t(23)=='23 ',`t(23)` + assert t('123456789abcdef')=='123456789a',`t('123456789abcdef')` + elif tname in ['t5','s5']: + assert t(23)=='23 ' + assert t('ab')=='ab ' + assert t('123456789abcdef')=='12345' + else: + raise NotImplementedError + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f90/return_complex.py b/numpy/f2py/tests/f90/return_complex.py new file mode 100644 index 000000000..e615de218 --- /dev/null +++ b/numpy/f2py/tests/f90/return_complex.py @@ -0,0 +1,126 @@ +__usage__ = """ +Run: + python return_complex.py [<f2py options>] +Examples: + python return_complex.py --quiet +""" + +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f90_ext_return_complex + except ImportError: + assert not f2py2e.compile('''\ +module f90_return_complex + contains + function t0(value) + complex :: value + complex :: t0 + t0 = value + end function t0 + function t8(value) + complex(kind=4) :: value + complex(kind=4) :: t8 + t8 = value + end function t8 + function t16(value) + complex(kind=8) :: value + complex(kind=8) :: t16 + t16 = value + end function t16 + function td(value) + double complex :: value + double complex :: td + td = value + end function td + + subroutine s0(t0,value) + complex :: value + complex :: t0 +!f2py intent(out) t0 + t0 = value + end subroutine s0 + subroutine s8(t8,value) + complex(kind=4) :: value + complex(kind=4) :: t8 +!f2py intent(out) t8 + t8 = value + end subroutine s8 + subroutine s16(t16,value) + complex(kind=8) :: value + complex(kind=8) :: t16 +!f2py intent(out) t16 + t16 = value + end subroutine s16 + subroutine sd(td,value) + double complex :: value + double complex :: td +!f2py intent(out) td + td = value + end subroutine sd +end module f90_return_complex +''','f90_ext_return_complex',f2py_opts,source_fn='f90_ret_cmlx.f90') + + from f90_ext_return_complex import f90_return_complex as m + test_functions = [m.t0,m.t8,m.t16,m.td,m.s0,m.s8,m.s16,m.sd] + return test_functions + + +def runtest(t): + tname = t.__doc__.split()[0] + if tname in ['t0','t8','s0','s8']: + err = 1e-5 + else: + err = 0.0 + #assert abs(t(234j)-234.0j)<=err + assert abs(t(234.6)-234.6)<=err + assert abs(t(234l)-234.0)<=err + assert abs(t(234.6+3j)-(234.6+3j))<=err + #assert abs(t('234')-234.)<=err + #assert abs(t('234.6')-234.6)<=err + assert abs(t(-234)+234.)<=err + assert abs(t([234])-234.)<=err + assert abs(t((234,))-234.)<=err + assert abs(t(array(234))-234.)<=err + assert abs(t(array(23+4j,'F'))-(23+4j))<=err + assert abs(t(array([234]))-234.)<=err + assert abs(t(array([[234]]))-234.)<=err + assert abs(t(array([234],'1'))+22.)<=err + assert abs(t(array([234],'s'))-234.)<=err + assert abs(t(array([234],'i'))-234.)<=err + assert abs(t(array([234],'l'))-234.)<=err + assert abs(t(array([234],'b'))-234.)<=err + assert abs(t(array([234],'f'))-234.)<=err + assert abs(t(array([234],'d'))-234.)<=err + assert abs(t(array([234+3j],'F'))-(234+3j))<=err + assert abs(t(array([234],'D'))-234.)<=err + + try: raise RuntimeError,`t(array([234],'c'))` + except TypeError: pass + try: raise RuntimeError,`t('abc')` + except TypeError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + try: + try: raise RuntimeError,`t(10l**400)` + except OverflowError: pass + except RuntimeError: + r = t(10l**400); assert `r` in ['(inf+0j)','(Infinity+0j)'],`r` + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f90/return_integer.py b/numpy/f2py/tests/f90/return_integer.py new file mode 100644 index 000000000..c0241eeaf --- /dev/null +++ b/numpy/f2py/tests/f90/return_integer.py @@ -0,0 +1,151 @@ +# XXX: investigate cases that are disabled under win32 +# + +__usage__ = """ +Run: + python return_integer.py [<f2py options>] +Examples: + python return_integer.py --quiet +""" + +import sys +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f90_ext_return_integer + except ImportError: + assert not f2py2e.compile('''\ +module f90_return_integer + contains + function t0(value) + integer :: value + integer :: t0 + t0 = value + end function t0 + function t1(value) + integer(kind=1) :: value + integer(kind=1) :: t1 + t1 = value + end function t1 + function t2(value) + integer(kind=2) :: value + integer(kind=2) :: t2 + t2 = value + end function t2 + function t4(value) + integer(kind=4) :: value + integer(kind=4) :: t4 + t4 = value + end function t4 + function t8(value) + integer(kind=8) :: value + integer(kind=8) :: t8 + t8 = value + end function t8 + + subroutine s0(t0,value) + integer :: value + integer :: t0 +!f2py intent(out) t0 + t0 = value + end subroutine s0 + subroutine s1(t1,value) + integer(kind=1) :: value + integer(kind=1) :: t1 +!f2py intent(out) t1 + t1 = value + end subroutine s1 + subroutine s2(t2,value) + integer(kind=2) :: value + integer(kind=2) :: t2 +!f2py intent(out) t2 + t2 = value + end subroutine s2 + subroutine s4(t4,value) + integer(kind=4) :: value + integer(kind=4) :: t4 +!f2py intent(out) t4 + t4 = value + end subroutine s4 + subroutine s8(t8,value) + integer(kind=8) :: value + integer(kind=8) :: t8 +!f2py intent(out) t8 + t8 = value + end subroutine s8 +end module f90_return_integer +''','f90_ext_return_integer',f2py_opts,source_fn='f90_ret_int.f90') + + from f90_ext_return_integer import f90_return_integer as m + test_functions = [m.t0,m.t1,m.t2,m.t4,m.t8,m.s0,m.s1,m.s2,m.s4,m.s8] + return test_functions + +def runtest(t): + tname = t.__doc__.split()[0] + assert t(123)==123 + assert t(123.6)==123 + assert t(123l)==123 + if sys.version[:3]<='2.2': + assert t(123.6+3j)==123 + assert t('123')==123 + assert t(-123)==-123 + assert t([123])==123 + assert t((123,))==123 + assert t(array(123))==123 + assert t(array([123]))==123 + assert t(array([[123]]))==123 + assert t(array([123],'1'))==123 + assert t(array([123],'s'))==123 + assert t(array([123],'i'))==123 + assert t(array([123],'l'))==123 + assert t(array([123],'b'))==123 + assert t(array([123],'f'))==123 + assert t(array([123],'d'))==123 + if sys.version[:3]<='2.2': + assert t(array([123+3j],'F'))==123 + assert t(array([123],'D'))==123 + + try: raise RuntimeError,`t(array([123],'c'))` + except ValueError: pass + try: raise RuntimeError,`t('abc')` + except ValueError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + if tname in ['t8','s8']: + try: raise RuntimeError,`t(100000000000000000000000l)` + except OverflowError: pass + try: raise RuntimeError,`t(10000000011111111111111.23)` + except OverflowError: pass + else: + if sys.version[:3]<='2.2': + try: raise RuntimeError,`t(10000000000000l)` + except OverflowError: pass + try: raise RuntimeError,`t(10000000000.23)` + except OverflowError: pass + +if __name__=='__main__': + #import libwadpy + status = 1 + try: + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' + status = 0 + finally: + if status: + print '*'*20 + print 'Running f2py2e.diagnose' + import f2py2e.diagnose + f2py2e.diagnose.run() diff --git a/numpy/f2py/tests/f90/return_logical.py b/numpy/f2py/tests/f90/return_logical.py new file mode 100644 index 000000000..71cfe162e --- /dev/null +++ b/numpy/f2py/tests/f90/return_logical.py @@ -0,0 +1,137 @@ +__usage__ = """ +Run: + python return_logical.py [<f2py options>] +Examples: + python return_logical.py --quiet +""" + +import f2py2e +from Numeric import array + +try: True +except NameError: + True = 1 + False = 0 + +def build(f2py_opts): + try: + import f90_ext_return_logical + except ImportError: + assert not f2py2e.compile('''\ +module f90_return_logical + contains + function t0(value) + logical :: value + logical :: t0 + t0 = value + end function t0 + function t1(value) + logical(kind=1) :: value + logical(kind=1) :: t1 + t1 = value + end function t1 + function t2(value) + logical(kind=2) :: value + logical(kind=2) :: t2 + t2 = value + end function t2 + function t4(value) + logical(kind=4) :: value + logical(kind=4) :: t4 + t4 = value + end function t4 + function t8(value) + logical(kind=8) :: value + logical(kind=8) :: t8 + t8 = value + end function t8 + + subroutine s0(t0,value) + logical :: value + logical :: t0 +!f2py intent(out) t0 + t0 = value + end subroutine s0 + subroutine s1(t1,value) + logical(kind=1) :: value + logical(kind=1) :: t1 +!f2py intent(out) t1 + t1 = value + end subroutine s1 + subroutine s2(t2,value) + logical(kind=2) :: value + logical(kind=2) :: t2 +!f2py intent(out) t2 + t2 = value + end subroutine s2 + subroutine s4(t4,value) + logical(kind=4) :: value + logical(kind=4) :: t4 +!f2py intent(out) t4 + t4 = value + end subroutine s4 + subroutine s8(t8,value) + logical(kind=8) :: value + logical(kind=8) :: t8 +!f2py intent(out) t8 + t8 = value + end subroutine s8 +end module f90_return_logical +''','f90_ext_return_logical',f2py_opts,source_fn='f90_ret_log.f90') + + from f90_ext_return_logical import f90_return_logical as m + test_functions = [m.t0,m.t1,m.t2,m.t4,m.t8,m.s0,m.s1,m.s2,m.s4,m.s8] + return test_functions + + + + +def runtest(t): + assert t(True)==1,`t(True)` + assert t(False)==0,`t(False)` + assert t(0)==0 + assert t(None)==0 + assert t(0.0)==0 + assert t(0j)==0 + assert t(1j)==1 + assert t(234)==1 + assert t(234.6)==1 + assert t(234l)==1 + assert t(234.6+3j)==1 + assert t('234')==1 + assert t('aaa')==1 + assert t('')==0 + assert t([])==0 + assert t(())==0 + assert t({})==0 + assert t(t)==1 + assert t(-234)==1 + assert t(10l**100)==1 + assert t([234])==1 + assert t((234,))==1 + assert t(array(234))==1 + assert t(array([234]))==1 + assert t(array([[234]]))==1 + assert t(array([234],'1'))==1 + assert t(array([234],'s'))==1 + assert t(array([234],'i'))==1 + assert t(array([234],'l'))==1 + assert t(array([234],'b'))==1 + assert t(array([234],'f'))==1 + assert t(array([234],'d'))==1 + assert t(array([234+3j],'F'))==1 + assert t(array([234],'D'))==1 + assert t(array(0))==0 + assert t(array([0]))==0 + assert t(array([[0]]))==0 + assert t(array([0j]))==0 + assert t(array([1]))==1 + assert t(array([0,0]))==0 + assert t(array([0,1]))==1 #XXX: is this expected? + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/f90/return_real.py b/numpy/f2py/tests/f90/return_real.py new file mode 100644 index 000000000..42d40cb95 --- /dev/null +++ b/numpy/f2py/tests/f90/return_real.py @@ -0,0 +1,129 @@ +__usage__ = """ +Run: + python return_real.py [<f2py options>] +Examples: + python return_real.py --quiet +""" + +import sys +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import f90_ext_return_real + except ImportError: + assert not f2py2e.compile('''\ +module f90_return_real + contains + function t0(value) + real :: value + real :: t0 + t0 = value + end function t0 + function t4(value) + real(kind=4) :: value + real(kind=4) :: t4 + t4 = value + end function t4 + function t8(value) + real(kind=8) :: value + real(kind=8) :: t8 + t8 = value + end function t8 + function td(value) + double precision :: value + double precision :: td + td = value + end function td + + subroutine s0(t0,value) + real :: value + real :: t0 +!f2py intent(out) t0 + t0 = value + end subroutine s0 + subroutine s4(t4,value) + real(kind=4) :: value + real(kind=4) :: t4 +!f2py intent(out) t4 + t4 = value + end subroutine s4 + subroutine s8(t8,value) + real(kind=8) :: value + real(kind=8) :: t8 +!f2py intent(out) t8 + t8 = value + end subroutine s8 + subroutine sd(td,value) + double precision :: value + double precision :: td +!f2py intent(out) td + td = value + end subroutine sd +end module f90_return_real +''','f90_ext_return_real',f2py_opts,source_fn='f90_ret_real.f90') + + from f90_ext_return_real import f90_return_real as m + test_functions = [m.t0,m.t4,m.t8,m.td,m.s0,m.s4,m.s8,m.sd] + return test_functions + +def runtest(t): + tname = t.__doc__.split()[0] + if tname in ['t0','t4','s0','s4']: + err = 1e-5 + else: + err = 0.0 + assert abs(t(234)-234.0)<=err + assert abs(t(234.6)-234.6)<=err + assert abs(t(234l)-234.0)<=err + if sys.version[:3]<='2.2': + assert abs(t(234.6+3j)-234.6)<=err,`t(234.6+3j)` + assert abs(t('234')-234)<=err + assert abs(t('234.6')-234.6)<=err + assert abs(t(-234)+234)<=err + assert abs(t([234])-234)<=err + assert abs(t((234,))-234.)<=err + assert abs(t(array(234))-234.)<=err + assert abs(t(array([234]))-234.)<=err + assert abs(t(array([[234]]))-234.)<=err + assert abs(t(array([234],'1'))+22)<=err + assert abs(t(array([234],'s'))-234.)<=err + assert abs(t(array([234],'i'))-234.)<=err + assert abs(t(array([234],'l'))-234.)<=err + assert abs(t(array([234],'b'))-234.)<=err + assert abs(t(array([234],'f'))-234.)<=err + assert abs(t(array([234],'d'))-234.)<=err + if sys.version[:3]<='2.2': + assert abs(t(array([234+3j],'F'))-234.)<=err,`t(array([234+3j],'F'))` + assert abs(t(array([234],'D'))-234.)<=err,`t(array([234],'D'))` + if tname in ['t0','t4','s0','s4']: + assert t(1e200)==t(1e300) # inf + + try: raise RuntimeError,`t(array([234],'c'))` + except ValueError: pass + try: raise RuntimeError,`t('abc')` + except ValueError: pass + + try: raise RuntimeError,`t([])` + except IndexError: pass + try: raise RuntimeError,`t(())` + except IndexError: pass + + try: raise RuntimeError,`t(t)` + except TypeError: pass + try: raise RuntimeError,`t({})` + except TypeError: pass + + try: + try: raise RuntimeError,`t(10l**400)` + except OverflowError: pass + except RuntimeError: + r = t(10l**400); assert `r` in ['inf','Infinity'],`r` + +if __name__=='__main__': + #import libwadpy + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/mixed/foo.f b/numpy/f2py/tests/mixed/foo.f new file mode 100644 index 000000000..c34742578 --- /dev/null +++ b/numpy/f2py/tests/mixed/foo.f @@ -0,0 +1,5 @@ + subroutine bar11(a) +cf2py intent(out) a + integer a + a = 11 + end diff --git a/numpy/f2py/tests/mixed/foo_fixed.f90 b/numpy/f2py/tests/mixed/foo_fixed.f90 new file mode 100644 index 000000000..7543a6acb --- /dev/null +++ b/numpy/f2py/tests/mixed/foo_fixed.f90 @@ -0,0 +1,8 @@ + module foo_fixed + contains + subroutine bar12(a) +!f2py intent(out) a + integer a + a = 12 + end subroutine bar12 + end module foo_fixed diff --git a/numpy/f2py/tests/mixed/foo_free.f90 b/numpy/f2py/tests/mixed/foo_free.f90 new file mode 100644 index 000000000..c1b641f13 --- /dev/null +++ b/numpy/f2py/tests/mixed/foo_free.f90 @@ -0,0 +1,8 @@ +module foo_free +contains + subroutine bar13(a) + !f2py intent(out) a + integer a + a = 13 + end subroutine bar13 +end module foo_free diff --git a/numpy/f2py/tests/mixed/run.py b/numpy/f2py/tests/mixed/run.py new file mode 100644 index 000000000..6f4b7d444 --- /dev/null +++ b/numpy/f2py/tests/mixed/run.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python +__usage__ = """ +Run: + python run.py [<f2py options>] +Examples: + python run.py --quiet +""" + +import os +import sys +import string +import f2py2e +from Numeric import array + +def build(f2py_opts): + try: + import mixed_f77_f90 + except: + d,b=os.path.split(sys.argv[0]) + files = ['foo.f','foo_fixed.f90','foo_free.f90'] + files = [os.path.join(d,f) for f in files] + files = string.join(files) + args = ' -c -m mixed_f77_f90 %s %s'%(files,f2py_opts) + c = '%s -c "import f2py2e;f2py2e.main()" %s' %(sys.executable,args) + s = os.system(c) + assert not s + from mixed_f77_f90 import bar11 + test_functions = [bar11] + from mixed_f77_f90 import foo_fixed as m + test_functions.append(m.bar12) + from mixed_f77_f90 import foo_free as m + test_functions.append(m.bar13) + return test_functions + +def runtest(t): + tname = t.__doc__.split()[0] + if tname=='bar11': + assert t()==11 + elif tname=='bar12': + assert t()==12 + elif tname=='bar13': + assert t()==13 + else: + raise NotImplementedError + +if __name__=='__main__': + repeat,f2py_opts = f2py2e.f2py_testing.cmdline() + test_functions = build(f2py_opts) + f2py2e.f2py_testing.run(runtest,test_functions,repeat) + print 'ok' diff --git a/numpy/f2py/tests/run_all.py b/numpy/f2py/tests/run_all.py new file mode 100755 index 000000000..016e68c29 --- /dev/null +++ b/numpy/f2py/tests/run_all.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python + +import os,sys + +opts = sys.argv[1:] +if not opts: + opts = ['10','--quiet'] + +NUMARRAY = "-DNUMARRAY" in sys.argv + +test_f77_files = [\ + 'f77/return_integer.py', + 'f77/return_logical.py', + 'f77/return_real.py', + 'f77/return_complex.py', + 'f77/callback.py', + ] + +if not NUMARRAY: # no support for character yet in numarray + test_f77_files.append('f77/return_character.py') + +test_f90_files = [\ + 'f90/return_integer.py', + 'f90/return_logical.py', + 'f90/return_real.py', + 'f90/return_complex.py', + 'f90/return_character.py', + 'mixed/run.py', + ] + +test_files = test_f77_files + +if NUMARRAY: + print >>sys.stderr,"NOTE: f2py for numarray does not support"\ + " f90 or character arrays." +else: + test_files += test_f90_files + +py_path = os.environ.get('PYTHONPATH') +if py_path is None: + py_path = '.' +else: + py_path = os.pathsep.join(['.',py_path]) +os.environ['PYTHONPATH'] = py_path + +for f in test_files: + print "**********************************************" + ff = os.path.join(sys.path[0],f) + args = [sys.executable,ff]+opts + print "Running",' '.join(args) + status = os.spawnve(os.P_WAIT,sys.executable,args,os.environ) + if status: + print 'TEST FAILURE (status=%s)' % (status) + if f=='f90/return_integer.py': + sys.exit() |