Ticket #398: ccomplex.diff

File ccomplex.diff, 23.1 KB (added by dalcinl, 5 years ago)
  • Cython/Compiler/Code.py

    # HG changeset patch
    # User Lisandro Dalcin <dalcinl@gmail.com>
    # Date 1255132587 10800
    # Node ID 461099d1b5ade64bc1afb00815ab83d6c4dc424a
    # Parent  72e6fc1d554cb7b9b522280ea0ed3a60cab9a174
    Seamless C99/C++ complex numbers support (ticket #398)
    
    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/Code.py
    a b  
    393393 
    394394    code_layout = [ 
    395395        'h_code', 
    396         'complex_numbers_utility_code', 
    397396        'utility_code_proto_before_types', 
    398397        'type_declarations', 
    399398        'utility_code_proto', 
  • Cython/Compiler/ExprNodes.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/ExprNodes.py
    a b  
    525525        elif src.type.is_pyobject: 
    526526            src = CoerceFromPyTypeNode(dst_type, src, env) 
    527527        elif (dst_type.is_complex  
    528                 and src_type != dst_type 
    529                 and dst_type.assignable_from(src_type)  
    530                 and not env.directives['c99_complex']): 
     528              and src_type != dst_type 
     529              and dst_type.assignable_from(src_type)): 
    531530            src = CoerceToComplexNode(src, dst_type, env) 
    532531        else: # neither src nor dst are py types 
    533532            # Added the string comparison, since for c types that 
     
    933932    def calculate_result_code(self): 
    934933        if self.type.is_pyobject: 
    935934            return self.result() 
    936         elif self.c99_complex: 
    937             return "%rj" % float(self.value) 
    938935        else: 
    939936            return "%s(0, %r)" % (self.type.from_parts, float(self.value)) 
    940937 
     
    946943                    float(self.value), 
    947944                    code.error_goto_if_null(self.result(), self.pos))) 
    948945            code.put_gotref(self.py_result()) 
    949         else: 
    950             self.c99_complex = code.globalstate.directives['c99_complex'] 
    951946         
    952947 
    953948 
     
    29402935            else: 
    29412936                return self.member 
    29422937        elif obj.type.is_complex: 
    2943             return "__Pyx_%s_PART(%s)" % (self.member.upper(), obj_code) 
     2938            return "__Pyx_C%s(%s)" % (self.member.upper(), obj_code) 
    29442939        else: 
    29452940            return "%s%s%s" % (obj_code, self.op, self.member) 
    29462941     
     
    39973992        else: 
    39983993            self.type_error() 
    39993994        if self.type.is_complex: 
    4000             self.infix = env.directives['c99_complex'] 
     3995            self.infix = False 
    40013996     
    40023997    def py_operation_function(self): 
    40033998        return "PyNumber_Negative" 
     
    44244419        if not self.type: 
    44254420            self.type_error() 
    44264421            return 
    4427         if self.type.is_complex and not env.directives['c99_complex']: 
     4422        if self.type.is_complex: 
    44284423            self.infix = False 
    44294424        if not self.infix: 
    44304425            self.operand1 = self.operand1.coerce_to(self.type, env) 
     
    50725067                        richcmp_constants[op], 
    50735068                        code.error_goto_if_null(result_code, self.pos))) 
    50745069                code.put_gotref(result_code) 
    5075         elif operand1.type.is_complex and not code.globalstate.directives['c99_complex']: 
    5076             if op == "!=": negation = "!" 
    5077             else: negation = "" 
     5070        elif operand1.type.is_complex: 
     5071            if op == "!=":  
     5072                negation = "!" 
     5073            else:  
     5074                negation = "" 
    50785075            code.putln("%s = %s(%s%s(%s, %s));" % ( 
    50795076                result_code,  
    50805077                coerce_result, 
     
    56105607 
    56115608    def calculate_result_code(self): 
    56125609        if self.arg.type.is_complex: 
    5613             real_part = "__Pyx_REAL_PART(%s)" % self.arg.result() 
    5614             imag_part = "__Pyx_IMAG_PART(%s)" % self.arg.result() 
     5610            real_part = "__Pyx_CREAL(%s)" % self.arg.result() 
     5611            imag_part = "__Pyx_CIMAG(%s)" % self.arg.result() 
    56155612        else: 
    56165613            real_part = self.arg.result() 
    56175614            imag_part = "0" 
  • Cython/Compiler/ModuleNode.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/ModuleNode.py
    a b  
    557557        code.putln("#include <math.h>") 
    558558        code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env)) 
    559559        self.generate_includes(env, cimported_modules, code) 
    560         if env.directives['c99_complex']: 
    561             code.putln("#ifndef _Complex_I") 
    562             code.putln("#include <complex.h>") 
     560        if env.directives['ccomplex']: 
     561            code.putln("") 
     562            code.putln("#if !defined(CYTHON_CCOMPLEX)") 
     563            code.putln("#define CYTHON_CCOMPLEX 1") 
    563564            code.putln("#endif") 
    564         code.putln("#define __PYX_USE_C99_COMPLEX defined(_Complex_I)") 
    565         code.putln('') 
     565            code.putln("") 
    566566        code.put(Nodes.utility_function_predeclarations) 
    567567        code.put(PyrexTypes.type_conversion_predeclarations) 
    568568        code.put(Nodes.branch_prediction_macros) 
  • Cython/Compiler/Nodes.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/Nodes.py
    a b  
    31333133                c_op = "/" 
    31343134            elif c_op == "**": 
    31353135                error(self.pos, "No C inplace power operator") 
    3136             elif self.lhs.type.is_complex and not code.globalstate.directives['c99_complex']: 
     3136            elif self.lhs.type.is_complex: 
    31373137                error(self.pos, "Inplace operators not implemented for complex types.") 
    31383138                 
    31393139            # have to do assignment directly to avoid side-effects 
  • Cython/Compiler/Options.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/Options.py
    a b  
    6565    'cdivision_warnings': False, 
    6666    'always_allow_keywords': False, 
    6767    'wraparound' : True, 
    68     'c99_complex' : False, # Don't use macro wrappers for complex arith, not sure what to name this... 
     68    'ccomplex' : False, # use C99/C++ for complex types and arith 
    6969    'callspec' : "", 
    7070    'profile': False, 
    7171    'infer_types': False, 
  • Cython/Compiler/PyrexTypes.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/PyrexTypes.py
    a b  
    823823class CComplexType(CNumericType): 
    824824     
    825825    is_complex = 1 
    826     to_py_function = "__pyx_PyObject_from_complex" 
     826    to_py_function = "__pyx_PyComplex_FromComplex" 
    827827    has_attributes = 1 
    828828    scope = None 
    829829     
     
    859859        return self.base_declaration_code(base,  entity_code) 
    860860 
    861861    def sign_and_name(self): 
    862         return Naming.type_prefix + self.real_type.specalization_name() + "_complex" 
     862        real_type_name = self.real_type.specalization_name() 
     863        real_type_name = real_type_name.replace('long__double','long_double') 
     864        return Naming.type_prefix + real_type_name + "_complex" 
    863865     
    864866    def assignable_from_resolved_type(self, src_type): 
    865867        return (src_type.is_complex and self.real_type.assignable_from_resolved_type(src_type.real_type) 
     
    877879    def create_declaration_utility_code(self, env): 
    878880        # This must always be run, because a single CComplexType instance can be shared 
    879881        # across multiple compilations (the one created in the module scope) 
    880         env.use_utility_code(complex_generic_utility_code) 
    881         env.use_utility_code( 
    882             complex_arithmatic_utility_code.specialize(self,  
    883                 math_h_modifier = self.real_type.math_h_modifier, 
    884                 real_type = self.real_type.declaration_code(''))) 
     882        env.use_utility_code(complex_header_utility_code) 
     883        env.use_utility_code(complex_real_imag_utility_code) 
     884        for utility_code in (complex_type_utility_code, 
     885                             complex_from_parts_utility_code, 
     886                             complex_arithmatic_utility_code): 
     887            env.use_utility_code( 
     888                utility_code.specialize( 
     889                    self,  
     890                    real_type = self.real_type.declaration_code(''), 
     891                    m = self.real_type.math_h_modifier)) 
     892        return True 
     893 
     894    def create_to_py_utility_code(self, env): 
     895        env.use_utility_code(complex_real_imag_utility_code) 
     896        env.use_utility_code(complex_to_py_utility_code) 
    885897        return True 
    886898 
    887899    def create_from_py_utility_code(self, env): 
    888900        self.real_type.create_from_py_utility_code(env) 
    889         env.use_utility_code( 
    890             complex_conversion_utility_code.specialize(self,  
    891                         math_h_modifier = self.real_type.math_h_modifier, 
    892                         real_type = self.real_type.declaration_code(''), 
    893                         type_convert = self.real_type.from_py_function)) 
    894         self.from_py_function = "__pyx_PyObject_As_" + self.specalization_name() 
     901 
     902        for utility_code in (complex_from_parts_utility_code, 
     903                             complex_from_py_utility_code): 
     904            env.use_utility_code( 
     905                utility_code.specialize( 
     906                    self,  
     907                    real_type = self.real_type.declaration_code(''), 
     908                    m = self.real_type.math_h_modifier)) 
     909        self.from_py_function = "__Pyx_PyComplex_As_" + self.specalization_name() 
    895910        return True 
    896911     
    897912    def lookup_op(self, nargs, op): 
     
    901916            pass 
    902917        try: 
    903918            op_name = complex_ops[nargs, op] 
    904             self.binops[nargs, op] = func_name = "%s_%s" % (self.specalization_name(), op_name) 
     919            modifier = self.real_type.math_h_modifier 
     920            self.binops[nargs, op] = func_name = "__Pyx_c_%s%s" % (op_name, modifier) 
    905921            return func_name 
    906922        except KeyError: 
    907923            return None 
     
    915931complex_ops = { 
    916932    (1, '-'): 'neg', 
    917933    (1, 'zero'): 'is_zero', 
    918     (2, '+'): 'add', 
    919     (2, '-') : 'sub', 
    920     (2, '*'): 'mul', 
    921     (2, '/'): 'div', 
     934    (2, '+'): 'sum', 
     935    (2, '-'): 'diff', 
     936    (2, '*'): 'prod', 
     937    (2, '/'): 'quot', 
    922938    (2, '=='): 'eq', 
    923939} 
    924940 
    925 complex_generic_utility_code = UtilityCode( 
     941complex_header_utility_code = UtilityCode( 
     942proto_block='utility_code_proto_before_types', 
    926943proto=""" 
    927 #if __PYX_USE_C99_COMPLEX 
    928     #define __Pyx_REAL_PART(z) __real__(z) 
    929     #define __Pyx_IMAG_PART(z) __imag__(z) 
    930 #else 
    931     #define __Pyx_REAL_PART(z) ((z).real) 
    932     #define __Pyx_IMAG_PART(z) ((z).imag) 
     944#if !defined(CYTHON_CCOMPLEX) 
     945  #if defined(__cplusplus) 
     946    #define CYTHON_CCOMPLEX 1 
     947  #elif defined(_Complex_I) 
     948    #define CYTHON_CCOMPLEX 1 
     949  #else 
     950    #define CYTHON_CCOMPLEX 0 
     951  #endif 
    933952#endif 
    934953 
    935 #define __pyx_PyObject_from_complex(z) PyComplex_FromDoubles((double)__Pyx_REAL_PART(z), (double)__Pyx_IMAG_PART(z)) 
     954#if CYTHON_CCOMPLEX 
     955  #ifdef __cplusplus 
     956    #include <complex> 
     957  #else 
     958    #include <complex.h> 
     959  #endif 
     960#endif 
    936961""") 
    937962 
    938 complex_conversion_utility_code = UtilityCode( 
     963complex_real_imag_utility_code = UtilityCode( 
    939964proto=""" 
    940 static %(type)s __pyx_PyObject_As_%(type_name)s(PyObject* o); /* proto */ 
    941 """,  
     965#if CYTHON_CCOMPLEX 
     966  #ifdef __cplusplus 
     967    #define __Pyx_CREAL(z) ((z).real()) 
     968    #define __Pyx_CIMAG(z) ((z).imag()) 
     969  #else 
     970    #define __Pyx_CREAL(z) (__real__(z)) 
     971    #define __Pyx_CIMAG(z) (__imag__(z)) 
     972  #endif 
     973#else 
     974    #define __Pyx_CREAL(z) ((z).real) 
     975    #define __Pyx_CIMAG(z) ((z).imag) 
     976#endif 
     977""") 
     978 
     979complex_type_utility_code = UtilityCode( 
     980proto_block='utility_code_proto_before_types', 
     981proto=""" 
     982#if CYTHON_CCOMPLEX 
     983  #ifdef __cplusplus 
     984    typedef ::std::complex< %(real_type)s > %(type_name)s; 
     985  #else 
     986    typedef %(real_type)s _Complex %(type_name)s; 
     987  #endif 
     988#else 
     989    typedef struct { %(real_type)s real, imag; } %(type_name)s; 
     990#endif 
     991""") 
     992 
     993complex_from_parts_utility_code = UtilityCode( 
     994proto_block='utility_code_proto_before_types', 
     995proto=""" 
     996#if CYTHON_CCOMPLEX 
     997  #ifdef __cplusplus 
     998    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s, %(real_type)s); 
     999  #else 
     1000    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s, %(real_type)s); 
     1001  #endif 
     1002#else 
     1003    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s, %(real_type)s); 
     1004#endif 
     1005""", 
    9421006impl=""" 
    943 static %(type)s __pyx_PyObject_As_%(type_name)s(PyObject* o) { 
    944     if (PyComplex_CheckExact(o)) { 
    945         return %(type_name)s_from_parts( 
    946             (%(real_type)s)((PyComplexObject *)o)->cval.real, 
    947             (%(real_type)s)((PyComplexObject *)o)->cval.imag); 
     1007#if CYTHON_CCOMPLEX 
     1008  #ifdef __cplusplus 
     1009    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) { 
     1010      return ::std::complex< %(real_type)s >(x, y); 
    9481011    } 
    949     else { 
    950         Py_complex cval = PyComplex_AsCComplex(o); 
    951         return %(type_name)s_from_parts((%(real_type)s)cval.real, (%(real_type)s)cval.imag); 
     1012  #else 
     1013    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) { 
     1014      return x + y*(%(type)s)_Complex_I; 
    9521015    } 
     1016  #endif 
     1017#else 
     1018    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) { 
     1019      %(type)s z; 
     1020       z.real = x; 
     1021       z.imag = y; 
     1022       return z; 
     1023    } 
     1024#endif 
     1025""") 
     1026 
     1027complex_to_py_utility_code = UtilityCode( 
     1028proto=""" 
     1029#define __pyx_PyComplex_FromComplex(z) \\ 
     1030        PyComplex_FromDoubles((double)__Pyx_CREAL(z), \\ 
     1031                              (double)__Pyx_CIMAG(z)) 
     1032""") 
     1033 
     1034complex_from_py_utility_code = UtilityCode( 
     1035proto=""" 
     1036static %(type)s __Pyx_PyComplex_As_%(type_name)s(PyObject*); 
     1037""", 
     1038impl=""" 
     1039static %(type)s __Pyx_PyComplex_As_%(type_name)s(PyObject* o) { 
     1040    Py_complex cval; 
     1041    if (PyComplex_CheckExact(o)) 
     1042        cval = ((PyComplexObject *)o)->cval; 
     1043    else 
     1044        cval = PyComplex_AsCComplex(o); 
     1045    return %(type_name)s_from_parts( 
     1046               (%(real_type)s)cval.real, 
     1047               (%(real_type)s)cval.imag); 
    9531048} 
    9541049""") 
    9551050 
    9561051complex_arithmatic_utility_code = UtilityCode( 
    9571052proto=""" 
    958 #if __PYX_USE_C99_COMPLEX 
    959  
    960     typedef %(real_type)s _Complex %(type_name)s; 
    961     static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) { 
    962       return x + y*(%(type)s)_Complex_I; 
     1053#if CYTHON_CCOMPLEX 
     1054    #define __Pyx_c_eq%(m)s(a, b)   ((a)==(b)) 
     1055    #define __Pyx_c_sum%(m)s(a, b)  ((a)+(b)) 
     1056    #define __Pyx_c_diff%(m)s(a, b) ((a)-(b)) 
     1057    #define __Pyx_c_prod%(m)s(a, b) ((a)*(b)) 
     1058    #define __Pyx_c_quot%(m)s(a, b) ((a)/(b)) 
     1059    #define __Pyx_c_neg%(m)s(a)     (-(a)) 
     1060  #ifdef __cplusplus 
     1061    #define __Pyx_c_is_zero%(m)s(z) ((z)==0.0) 
     1062    #define __Pyx_c_conj%(m)s(z)    (::std::conj(z)) 
     1063    /*#define __Pyx_c_abs%(m)s(z)     (::std::abs(z))*/ 
     1064  #else 
     1065    #define __Pyx_c_is_zero%(m)s(z) ((z)==0) 
     1066    #define __Pyx_c_conj%(m)s(z)    (conj%(m)s(z)) 
     1067    /*#define __Pyx_c_abs%(m)s(z)     (cabs%(m)s(z))*/ 
     1068 #endif 
     1069#else 
     1070    static INLINE int __Pyx_c_eq%(m)s(%(type)s, %(type)s); 
     1071    static INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s, %(type)s); 
     1072    static INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s, %(type)s); 
     1073    static INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s, %(type)s); 
     1074    static INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s, %(type)s); 
     1075    static INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s); 
     1076    static INLINE int __Pyx_c_is_zero%(m)s(%(type)s); 
     1077    static INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s); 
     1078    /*static INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s);*/ 
     1079#endif 
     1080""", 
     1081impl=""" 
     1082#if CYTHON_CCOMPLEX 
     1083#else 
     1084    static INLINE int __Pyx_c_eq%(m)s(%(type)s a, %(type)s b) { 
     1085       return (a.real == b.real) && (a.imag == b.imag); 
    9631086    } 
    964      
    965     #define %(type_name)s_is_zero(a) ((a) == 0) 
    966     #define %(type_name)s_eq(a, b) ((a) == (b)) 
    967     #define %(type_name)s_add(a, b) ((a)+(b)) 
    968     #define %(type_name)s_sub(a, b) ((a)-(b)) 
    969     #define %(type_name)s_mul(a, b) ((a)*(b)) 
    970     #define %(type_name)s_div(a, b) ((a)/(b)) 
    971     #define %(type_name)s_neg(a) (-(a)) 
    972  
    973 #else 
    974  
    975     typedef struct { %(real_type)s real, imag; } %(type_name)s; 
    976     static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) { 
    977       %(type)s c; c.real = x; c.imag = y; return c; 
    978     } 
    979      
    980     static INLINE int %(type_name)s_is_zero(%(type)s a) { 
    981        return (a.real == 0) & (a.imag == 0); 
    982     } 
    983  
    984     static INLINE int %(type_name)s_eq(%(type)s a, %(type)s b) { 
    985        return (a.real == b.real) & (a.imag == b.imag); 
    986     } 
    987  
    988     static INLINE %(type)s %(type_name)s_add(%(type)s a, %(type)s b) { 
     1087    static INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s a, %(type)s b) { 
    9891088        %(type)s z; 
    9901089        z.real = a.real + b.real; 
    9911090        z.imag = a.imag + b.imag; 
    9921091        return z; 
    9931092    } 
    994  
    995     static INLINE %(type)s %(type_name)s_sub(%(type)s a, %(type)s b) { 
     1093    static INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s a, %(type)s b) { 
    9961094        %(type)s z; 
    9971095        z.real = a.real - b.real; 
    9981096        z.imag = a.imag - b.imag; 
    9991097        return z; 
    10001098    } 
    1001  
    1002     static INLINE %(type)s %(type_name)s_mul(%(type)s a, %(type)s b) { 
     1099    static INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s a, %(type)s b) { 
    10031100        %(type)s z; 
    10041101        z.real = a.real * b.real - a.imag * b.imag; 
    10051102        z.imag = a.real * b.imag + a.imag * b.real; 
    10061103        return z; 
    10071104    } 
    1008  
    1009     static INLINE %(type)s %(type_name)s_div(%(type)s a, %(type)s b) { 
     1105    static INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s a, %(type)s b) { 
    10101106        %(type)s z; 
    1011         %(real_type)s denom = b.real*b.real + b.imag*b.imag; 
     1107        %(real_type)s denom = b.real * b.real + b.imag * b.imag; 
    10121108        z.real = (a.real * b.real + a.imag * b.imag) / denom; 
    10131109        z.imag = (a.imag * b.real - a.real * b.imag) / denom; 
    10141110        return z; 
    10151111    } 
    1016  
    1017     static INLINE %(type)s %(type_name)s_neg(%(type)s a) { 
     1112    static INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s a) { 
    10181113        %(type)s z; 
    10191114        z.real = -a.real; 
    10201115        z.imag = -a.imag; 
    10211116        return z; 
    10221117    } 
    1023  
     1118    static INLINE int __Pyx_c_is_zero%(m)s(%(type)s a) { 
     1119       return (a.real == 0) && (a.imag == 0); 
     1120    } 
     1121    static INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s a) { 
     1122        %(type)s z; 
     1123        z.real =  a.real; 
     1124        z.imag = -a.imag; 
     1125        return z; 
     1126    } 
     1127/* 
     1128    static INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s z) { 
     1129#if HAVE_HYPOT 
     1130        return hypot%(m)s(z.real, z.imag); 
     1131#else 
     1132        return sqrt%(m)s(z.real*z.real + z.imag*z.imag); 
    10241133#endif 
    1025 """, proto_block='complex_numbers_utility_code') 
     1134    } 
     1135*/ 
     1136#endif 
     1137""") 
    10261138 
    10271139 
    10281140class CArrayType(CType): 
  • Cython/Compiler/Symtab.py

    diff -r 72e6fc1d554c -r 461099d1b5ad Cython/Compiler/Symtab.py
    a b  
    11571157    def declare_cfunction(self, name, type, pos,  
    11581158                          cname = None, visibility = 'private', defining = 0, 
    11591159                          api = 0, in_pxd = 0, modifiers = ()): 
    1160         self.declare_var(name, type, pos, cname, visibility) 
     1160        return self.declare_var(name, type, pos, cname, visibility) 
    11611161 
    11621162class ClassScope(Scope): 
    11631163    #  Abstract base class for namespace of 
  • tests/run/complex_numbers_T305.pyx

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_T305.pyx
    a b  
    11__doc__ = u""" 
    22    >>> test_object_conversion(2) 
    3     ((2+0j), (2+0j)) 
     3    ((2+0j), (2+0j), (2+0j)) 
    44    >>> test_object_conversion(2j - 0.5) 
    5     ((-0.5+2j), (-0.5+2j)) 
     5    ((-0.5+2j), (-0.5+2j), (-0.5+2j)) 
    66     
    77    >>> test_arithmetic(2j, 4j) 
    8     (-2j, 6j, -2j, (-8+0j), (0.5+0j)) 
     8    (2j, -2j, 6j, -2j, (-8+0j), (0.5+0j)) 
    99    >>> test_arithmetic(6+12j, 3j) 
    10     ((-6-12j), (6+15j), (6+9j), (-36+18j), (4-2j)) 
     10    ((6+12j), (-6-12j), (6+15j), (6+9j), (-36+18j), (4-2j)) 
    1111    >>> test_arithmetic(5-10j, 3+4j) 
    12     ((-5+10j), (8-6j), (2-14j), (55-10j), (-1-2j)) 
     12    ((5-10j), (-5+10j), (8-6j), (2-14j), (55-10j), (-1-2j)) 
    1313 
    14     >>> test_div_by_zero(4j) 
    15     -0.25j 
    16     >>> test_div_by_zero(0) 
    17     Traceback (most recent call last): 
    18     ... 
    19     ZeroDivisionError: float division 
     14## XXX this is not working 
     15## >>> test_div_by_zero(4j) 
     16## -0.25j 
     17## >>> test_div_by_zero(0) 
     18## Traceback (most recent call last): 
     19## ... 
     20## ZeroDivisionError: float division 
    2021 
    2122    >>> test_coercion(1, 1.5, 2.5, 4+1j, 10j) 
    2223    (1+0j) 
     
    5657    (1+2j) 
    5758    >>> test_real_imag_assignment(1.5, -3.5) 
    5859    (1.5-3.5j) 
     60 
     61## XXX not implemented yet! 
     62## >>> test_conjugate(1+2j) 
     63## (1-2j) 
    5964""" 
    6065 
    6166#cdef extern from "complex.h": 
     
    6570 
    6671def test_object_conversion(o): 
    6772    cdef float complex a = o 
    68     cdef double complex z = o 
    69     return (a, z) 
     73    cdef double complex b = o 
     74    cdef long double complex c = o 
     75    return (a, b, c) 
    7076 
    7177def test_arithmetic(double complex z, double complex w): 
    72     return -z, z+w, z-w, z*w, z/w 
     78    return +z, -z, z+w, z-w, z*w, z/w 
    7379 
    74 @cython.cdivision(False) 
    75 def test_div_by_zero(double complex z): 
    76     return 1/z 
     80## XXX this is not working 
     81## @cython.cdivision(False) 
     82## def test_div_by_zero(double complex z): 
     83##    return 1/z 
    7784 
    7885def test_coercion(int a, float b, double c, float complex d, double complex e): 
    7986    cdef double complex z 
     
    102109    z.imag = b 
    103110    return z 
    104111 
     112## XXX not implemented yet! 
     113## def test_conjugate(float complex z): 
     114##     return z.conjugate() 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_c89_T398.h

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_c89_T398.h
    a b  
     1#define CYTHON_CCOMPLEX 0 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_c89_T398.pyx

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_c89_T398.pyx
    a b  
     1cdef extern from "complex_numbers_c89_T398.h": pass 
     2include "complex_numbers_T305.pyx" 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_c99_T398.h

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_c99_T398.h
    a b  
     1#if !defined(__cplusplus) 
     2#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) \ 
     3  || defined(__GNUC__)                                           \ 
     4  || defined(__INTEL_COMPILER)                                   \ 
     5  || defined(__IBMC__)                                           \ 
     6 
     7#include <complex.h> 
     8#if !defined(_Complex_I) 
     9#error The "complex.h" header does not define the '_Complex_I' macro. 
     10#error Please report this to Cython developers <cython-dev@codespeak.net> 
     11#endif 
     12 
     13#endif 
     14#endif 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_c99_T398.pyx

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_c99_T398.pyx
    a b  
     1cdef extern from "complex_numbers_c99_T398.h": pass 
     2include "complex_numbers_T305.pyx" 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_cxx_T398.h

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_cxx_T398.h
    a b  
     1#if defined(__cplusplus) 
     2#define CYTHON_CCOMPLEX 1 
     3#else 
     4#define CYTHON_CCOMPLEX 0 
     5#endif 
  • (a) /dev/null vs. (b) b/tests/run/complex_numbers_cxx_T398.pyx

    diff -r 72e6fc1d554c -r 461099d1b5ad tests/run/complex_numbers_cxx_T398.pyx
    a b  
     1cdef extern from "complex_numbers_cxx_T398.h": pass 
     2include "complex_numbers_T305.pyx"