示例#1
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call2,
                                                            convert_to_array,
                                                            Scalar,
                                                            shape_agreement)

        [w_lhs, w_rhs] = args_w
        w_lhs = convert_to_array(space, w_lhs)
        w_rhs = convert_to_array(space, w_rhs)
        calc_dtype = find_binop_result_dtype(
            space,
            w_lhs.find_dtype(),
            w_rhs.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_bools=self.promote_bools,
        )
        if self.comparison_func:
            res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
        else:
            res_dtype = calc_dtype
        if isinstance(w_lhs, Scalar) and isinstance(w_rhs, Scalar):
            return self.func(calc_dtype, w_lhs.value.convert_to(calc_dtype),
                             w_rhs.value.convert_to(calc_dtype))

        new_shape = shape_agreement(space, w_lhs.shape, w_rhs.shape)
        w_res = Call2(self.func, self.name, new_shape, calc_dtype, res_dtype,
                      w_lhs, w_rhs)
        w_lhs.add_invalidates(w_res)
        w_rhs.add_invalidates(w_res)
        return w_res
示例#2
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call2,
            convert_to_array, Scalar, shape_agreement)

        [w_lhs, w_rhs] = args_w
        w_lhs = convert_to_array(space, w_lhs)
        w_rhs = convert_to_array(space, w_rhs)
        calc_dtype = find_binop_result_dtype(space,
            w_lhs.find_dtype(), w_rhs.find_dtype(),
            int_only=self.int_only,
            promote_to_float=self.promote_to_float,
            promote_bools=self.promote_bools,
        )
        if self.comparison_func:
            res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
        else:
            res_dtype = calc_dtype
        if isinstance(w_lhs, Scalar) and isinstance(w_rhs, Scalar):
            return space.wrap(self.func(calc_dtype,
                w_lhs.value.convert_to(calc_dtype),
                w_rhs.value.convert_to(calc_dtype)
            ))
        new_shape = shape_agreement(space, w_lhs.shape, w_rhs.shape)
        w_res = Call2(self.func, self.name,
                      new_shape, calc_dtype,
                      res_dtype, w_lhs, w_rhs)
        w_lhs.add_invalidates(w_res)
        w_rhs.add_invalidates(w_res)
        return w_res
示例#3
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call2,
            convert_to_array, Scalar, shape_agreement)

        [w_lhs, w_rhs] = args_w
        w_lhs = convert_to_array(space, w_lhs)
        w_rhs = convert_to_array(space, w_rhs)
        calc_dtype = find_binop_result_dtype(space,
            w_lhs.find_dtype(), w_rhs.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_bools=self.promote_bools,
        )
        if self.comparison_func:
            res_dtype = space.fromcache(interp_dtype.W_BoolDtype)
        else:
            res_dtype = calc_dtype
        if isinstance(w_lhs, Scalar) and isinstance(w_rhs, Scalar):
            return self.func(calc_dtype,
                w_lhs.value.convert_to(calc_dtype),
                w_rhs.value.convert_to(calc_dtype)
            ).wrap(space)

        new_sig = signature.Signature.find_sig([
            self.signature, w_lhs.signature, w_rhs.signature
        ])
        new_shape = shape_agreement(space, w_lhs.shape, w_rhs.shape)
        w_res = Call2(new_sig, new_shape, calc_dtype,
                      res_dtype, w_lhs, w_rhs)
        w_lhs.add_invalidates(w_res)
        w_rhs.add_invalidates(w_res)
        return w_res
示例#4
0
 def call(self, space, args_w):
     from pypy.module.micronumpy.interp_numarray import (Call2,
         convert_to_array, Scalar, shape_agreement, BaseArray)
     if len(args_w) > 2:
         [w_lhs, w_rhs, w_out] = args_w
     else:
         [w_lhs, w_rhs] = args_w
         w_out = None
     w_lhs = convert_to_array(space, w_lhs)
     w_rhs = convert_to_array(space, w_rhs)
     if space.is_w(w_out, space.w_None) or w_out is None:
         out = None
         calc_dtype = find_binop_result_dtype(space,
             w_lhs.find_dtype(), w_rhs.find_dtype(),
             int_only=self.int_only,
             promote_to_float=self.promote_to_float,
             promote_bools=self.promote_bools,
         )
     elif not isinstance(w_out, BaseArray):
         raise OperationError(space.w_TypeError, space.wrap(
                 'output must be an array'))
     else:
         out = w_out
         calc_dtype = out.find_dtype()
     if self.comparison_func:
         res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         res_dtype = calc_dtype
     if isinstance(w_lhs, Scalar) and isinstance(w_rhs, Scalar):
         arr = self.func(calc_dtype,
             w_lhs.value.convert_to(calc_dtype),
             w_rhs.value.convert_to(calc_dtype)
         )
         if isinstance(out,Scalar):
             out.value = arr
         elif isinstance(out, BaseArray):
             out.fill(space, arr)
         else:
             out = arr
         return space.wrap(out)
     new_shape = shape_agreement(space, w_lhs.shape, w_rhs.shape)
     # Test correctness of out.shape
     if out and out.shape != shape_agreement(space, new_shape, out.shape):
         raise operationerrfmt(space.w_ValueError,
             'output parameter shape mismatch, could not broadcast [%s]' +
             ' to [%s]',
             ",".join([str(x) for x in new_shape]),
             ",".join([str(x) for x in out.shape]),
             )
     w_res = Call2(self.func, self.name,
                   new_shape, calc_dtype,
                   res_dtype, w_lhs, w_rhs, out)
     w_lhs.add_invalidates(space, w_res)
     w_rhs.add_invalidates(space, w_res)
     if out:
         w_res.get_concrete()
     return w_res
示例#5
0
 def call(self, space, args_w):
     from pypy.module.micronumpy.interp_numarray import (Call2,
         convert_to_array, Scalar, shape_agreement, BaseArray)
     if len(args_w) > 2:
         [w_lhs, w_rhs, w_out] = args_w
     else:
         [w_lhs, w_rhs] = args_w
         w_out = None
     w_lhs = convert_to_array(space, w_lhs)
     w_rhs = convert_to_array(space, w_rhs)
     if space.is_w(w_out, space.w_None) or w_out is None:
         out = None
         calc_dtype = find_binop_result_dtype(space,
             w_lhs.find_dtype(), w_rhs.find_dtype(),
             int_only=self.int_only,
             promote_to_float=self.promote_to_float,
             promote_bools=self.promote_bools,
         )
     elif not isinstance(w_out, BaseArray):
         raise OperationError(space.w_TypeError, space.wrap(
                 'output must be an array'))
     else:
         out = w_out
         calc_dtype = out.find_dtype()
     if self.comparison_func:
         res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         res_dtype = calc_dtype
     if isinstance(w_lhs, Scalar) and isinstance(w_rhs, Scalar):
         arr = self.func(calc_dtype,
             w_lhs.value.convert_to(calc_dtype),
             w_rhs.value.convert_to(calc_dtype)
         )
         if isinstance(out,Scalar):
             out.value = arr
         elif isinstance(out, BaseArray):
             out.fill(space, arr)
         else:
             out = arr
         return space.wrap(out)
     new_shape = shape_agreement(space, w_lhs.shape, w_rhs.shape)
     # Test correctness of out.shape
     if out and out.shape != shape_agreement(space, new_shape, out.shape):
         raise operationerrfmt(space.w_ValueError,
             'output parameter shape mismatch, could not broadcast [%s]' +
             ' to [%s]',
             ",".join([str(x) for x in new_shape]),
             ",".join([str(x) for x in out.shape]),
             )
     w_res = Call2(self.func, self.name,
                   new_shape, calc_dtype,
                   res_dtype, w_lhs, w_rhs, out)
     w_lhs.add_invalidates(w_res)
     w_rhs.add_invalidates(w_res)
     if out:
         w_res.get_concrete()
     return w_res
示例#6
0
 def impl(space, w_lhs, w_rhs):
     from pypy.module.micronumpy.interp_numarray import Call2, convert_to_array
     if space.issequence_w(w_lhs) or space.issequence_w(w_rhs):
         w_lhs_arr = convert_to_array(space, w_lhs)
         w_rhs_arr = convert_to_array(space, w_rhs)
         new_sig = w_lhs_arr.signature.transition(signature).transition(w_rhs_arr.signature)
         w_res = Call2(func, w_lhs_arr, w_rhs_arr, new_sig)
         w_lhs_arr.invalidates.append(w_res)
         w_rhs_arr.invalidates.append(w_res)
         return w_res
     else:
         return space.wrap(func(space.float_w(w_lhs), space.float_w(w_rhs)))
示例#7
0
    def descr_reduce(self, space, w_obj):
        from pypy.module.micronumpy.interp_numarray import convert_to_array, Scalar

        if self.argcount != 2:
            raise OperationError(space.w_ValueError, space.wrap("reduce only "
                "supported for binary functions"))

        assert isinstance(self, W_Ufunc2)
        obj = convert_to_array(space, w_obj)
        if isinstance(obj, Scalar):
            raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
                "on a scalar"))

        size = obj.find_size()
        dtype = find_unaryop_result_dtype(
            space, obj.find_dtype(),
            promote_to_largest=True
        )
        start = 0
        if self.identity is None:
            if size == 0:
                raise operationerrfmt(space.w_ValueError, "zero-size array to "
                    "%s.reduce without identity", self.name)
            value = obj.eval(0).convert_to(dtype)
            start += 1
        else:
            value = self.identity.convert_to(dtype)
        new_sig = signature.Signature.find_sig([
            self.reduce_signature, obj.signature
        ])
        return self.reduce(new_sig, start, value, obj, dtype, size).wrap(space)
示例#8
0
    def reduce(self, space, w_obj, multidim):
        from pypy.module.micronumpy.interp_numarray import convert_to_array, Scalar
        if self.argcount != 2:
            raise OperationError(space.w_ValueError, space.wrap("reduce only "
                "supported for binary functions"))

        assert isinstance(self, W_Ufunc2)
        obj = convert_to_array(space, w_obj)
        if isinstance(obj, Scalar):
            raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
                "on a scalar"))

        size = obj.find_size()
        dtype = find_unaryop_result_dtype(
            space, obj.find_dtype(),
            promote_to_largest=True
        )
        start = obj.start_iter(obj.shape)
        shapelen = len(obj.shape)
        if shapelen > 1 and not multidim:
            raise OperationError(space.w_NotImplementedError,
                space.wrap("not implemented yet"))
        if self.identity is None:
            if size == 0:
                raise operationerrfmt(space.w_ValueError, "zero-size array to "
                    "%s.reduce without identity", self.name)
            value = obj.eval(start).convert_to(dtype)
            start = start.next(shapelen)
        else:
            value = self.identity.convert_to(dtype)
        new_sig = signature.Signature.find_sig([
            self.reduce_signature, obj.signature
        ])
        return self.reduce_loop(new_sig, shapelen, start, value, obj,
                           dtype).wrap(space)
示例#9
0
 def reduce(self, space, w_obj, multidim, promote_to_largest, dim,
            keepdims=False):
     from pypy.module.micronumpy.interp_numarray import convert_to_array, \
                                                        Scalar, ReduceArray
     if self.argcount != 2:
         raise OperationError(space.w_ValueError, space.wrap("reduce only "
             "supported for binary functions"))
     assert isinstance(self, W_Ufunc2)
     obj = convert_to_array(space, w_obj)
     if dim >= len(obj.shape):
         raise OperationError(space.w_ValueError, space.wrap("axis(=%d) out of bounds" % dim))
     if isinstance(obj, Scalar):
         raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
             "on a scalar"))
     size = obj.size
     if self.comparison_func:
         dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         dtype = find_unaryop_result_dtype(
             space, obj.find_dtype(),
             promote_to_float=self.promote_to_float,
             promote_to_largest=promote_to_largest,
             promote_bools=True
         )
     shapelen = len(obj.shape)
     if self.identity is None and size == 0:
         raise operationerrfmt(space.w_ValueError, "zero-size array to "
                 "%s.reduce without identity", self.name)
     if shapelen > 1 and dim >= 0:
         return self.do_axis_reduce(obj, dtype, dim, keepdims)
     arr = ReduceArray(self.func, self.name, self.identity, obj, dtype)
     return loop.compute(arr)
示例#10
0
 def impl(space, w_obj):
     from pypy.module.micronumpy.interp_numarray import Call1, convert_to_array
     if space.issequence_w(w_obj):
         w_obj_arr = convert_to_array(space, w_obj)
         w_res = Call1(func, w_obj_arr, w_obj_arr.signature.transition(signature))
         w_obj_arr.invalidates.append(w_res)
         return w_res
     else:
         return space.wrap(func(space.float_w(w_obj)))
示例#11
0
 def call(self, space, args_w):
     from pypy.module.micronumpy.interp_numarray import (Call1, BaseArray,
         convert_to_array, Scalar, shape_agreement)
     if len(args_w)<2:
         [w_obj] = args_w
         out = None
     else:
         [w_obj, out] = args_w
         if space.is_w(out, space.w_None):
             out = None
     w_obj = convert_to_array(space, w_obj)
     calc_dtype = find_unaryop_result_dtype(space,
                               w_obj.find_dtype(),
                               promote_to_float=self.promote_to_float,
                               promote_bools=self.promote_bools)
     if out:
         if not isinstance(out, BaseArray):
             raise OperationError(space.w_TypeError, space.wrap(
                                             'output must be an array'))
         res_dtype = out.find_dtype()
     elif self.bool_result:
         res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         res_dtype = calc_dtype
     if isinstance(w_obj, Scalar):
         arr = self.func(calc_dtype, w_obj.value.convert_to(calc_dtype))
         if isinstance(out,Scalar):
             out.value = arr
         elif isinstance(out, BaseArray):
             out.fill(space, arr)
         else:
             out = arr
         return space.wrap(out)
     if out:
         assert isinstance(out, BaseArray) # For translation
         broadcast_shape =  shape_agreement(space, w_obj.shape, out.shape)
         if not broadcast_shape or broadcast_shape != out.shape:
             raise operationerrfmt(space.w_ValueError,
                 'output parameter shape mismatch, could not broadcast [%s]' +
                 ' to [%s]',
                 ",".join([str(x) for x in w_obj.shape]),
                 ",".join([str(x) for x in out.shape]),
                 )
         w_res = Call1(self.func, self.name, out.shape, calc_dtype,
                                      res_dtype, w_obj, out)
         #Force it immediately
         w_res.get_concrete()
     else:
         w_res = Call1(self.func, self.name, w_obj.shape, calc_dtype,
                                      res_dtype, w_obj)
     w_obj.add_invalidates(w_res)
     return w_res
示例#12
0
 def call(self, space, args_w):
     from pypy.module.micronumpy.interp_numarray import (Call1, BaseArray,
         convert_to_array, Scalar, shape_agreement)
     if len(args_w)<2:
         [w_obj] = args_w
         out = None
     else:
         [w_obj, out] = args_w
         if space.is_w(out, space.w_None):
             out = None
     w_obj = convert_to_array(space, w_obj)
     calc_dtype = find_unaryop_result_dtype(space,
                               w_obj.find_dtype(),
                               promote_to_float=self.promote_to_float,
                               promote_bools=self.promote_bools)
     if out:
         if not isinstance(out, BaseArray):
             raise OperationError(space.w_TypeError, space.wrap(
                                             'output must be an array'))
         res_dtype = out.find_dtype()
     elif self.bool_result:
         res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         res_dtype = calc_dtype
     if isinstance(w_obj, Scalar):
         arr = self.func(calc_dtype, w_obj.value.convert_to(calc_dtype))
         if isinstance(out,Scalar):
             out.value = arr
         elif isinstance(out, BaseArray):
             out.fill(space, arr)
         else:
             out = arr
         return space.wrap(out)
     if out:
         assert isinstance(out, BaseArray) # For translation
         broadcast_shape =  shape_agreement(space, w_obj.shape, out.shape)
         if not broadcast_shape or broadcast_shape != out.shape:
             raise operationerrfmt(space.w_ValueError,
                 'output parameter shape mismatch, could not broadcast [%s]' +
                 ' to [%s]',
                 ",".join([str(x) for x in w_obj.shape]),
                 ",".join([str(x) for x in out.shape]),
                 )
         w_res = Call1(self.func, self.name, out.shape, calc_dtype,
                                      res_dtype, w_obj, out)
         #Force it immediately
         w_res.get_concrete()
     else:
         w_res = Call1(self.func, self.name, w_obj.shape, calc_dtype,
                                      res_dtype, w_obj)
     w_obj.add_invalidates(space, w_res)
     return w_res
示例#13
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call1,
            convert_to_array, Scalar)

        [w_obj] = args_w
        w_obj = convert_to_array(space, w_obj)
        res_dtype = find_unaryop_result_dtype(space,
            w_obj.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_bools=self.promote_bools,
        )
        if isinstance(w_obj, Scalar):
            return self.func(res_dtype, w_obj.value.convert_to(res_dtype))

        w_res = Call1(self.func, self.name, w_obj.shape, res_dtype, w_obj)
        w_obj.add_invalidates(w_res)
        return w_res
示例#14
0
    def reduce(self, space, w_obj, multidim, promote_to_largest, w_dim):
        from pypy.module.micronumpy.interp_numarray import convert_to_array, \
                                                           Scalar
        if self.argcount != 2:
            raise OperationError(
                space.w_ValueError,
                space.wrap("reduce only "
                           "supported for binary functions"))
        dim = space.int_w(w_dim)
        assert isinstance(self, W_Ufunc2)
        obj = convert_to_array(space, w_obj)
        if dim >= len(obj.shape):
            raise OperationError(space.w_ValueError,
                                 space.wrap("axis(=%d) out of bounds" % dim))
        if isinstance(obj, Scalar):
            raise OperationError(space.w_TypeError,
                                 space.wrap("cannot reduce "
                                            "on a scalar"))

        size = obj.size
        dtype = find_unaryop_result_dtype(
            space,
            obj.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_to_largest=promote_to_largest,
            promote_bools=True)
        shapelen = len(obj.shape)
        if self.identity is None and size == 0:
            raise operationerrfmt(
                space.w_ValueError, "zero-size array to "
                "%s.reduce without identity", self.name)
        if shapelen > 1 and dim >= 0:
            res = self.do_axis_reduce(obj, dtype, dim)
            return space.wrap(res)
        scalarsig = ScalarSignature(dtype)
        sig = find_sig(
            ReduceSignature(self.func, self.name, dtype, scalarsig,
                            obj.create_sig()), obj)
        frame = sig.create_frame(obj)
        if self.identity is None:
            value = sig.eval(frame, obj).convert_to(dtype)
            frame.next(shapelen)
        else:
            value = self.identity.convert_to(dtype)
        return self.reduce_loop(shapelen, sig, frame, value, obj, dtype)
示例#15
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call1,
                                                            convert_to_array,
                                                            Scalar)

        [w_obj] = args_w
        w_obj = convert_to_array(space, w_obj)
        res_dtype = find_unaryop_result_dtype(
            space,
            w_obj.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_bools=self.promote_bools,
        )
        if isinstance(w_obj, Scalar):
            return self.func(res_dtype, w_obj.value.convert_to(res_dtype))

        w_res = Call1(self.func, self.name, w_obj.shape, res_dtype, w_obj)
        w_obj.add_invalidates(w_res)
        return w_res
示例#16
0
    def call(self, space, args_w):
        from pypy.module.micronumpy.interp_numarray import (Call1,
            convert_to_array, Scalar)

        [w_obj] = args_w
        w_obj = convert_to_array(space, w_obj)
        calc_dtype = find_unaryop_result_dtype(space,
                                  w_obj.find_dtype(),
                                  promote_to_float=self.promote_to_float,
                                  promote_bools=self.promote_bools)
        if self.bool_result:
            res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
        else:
            res_dtype = calc_dtype
        if isinstance(w_obj, Scalar):
            return space.wrap(self.func(calc_dtype, w_obj.value.convert_to(calc_dtype)))

        w_res = Call1(self.func, self.name, w_obj.shape, calc_dtype, res_dtype,
                      w_obj)
        w_obj.add_invalidates(w_res)
        return w_res
示例#17
0
    def reduce(self, space, w_obj, multidim, promote_to_largest, w_dim):
        from pypy.module.micronumpy.interp_numarray import convert_to_array, \
                                                           Scalar
        if self.argcount != 2:
            raise OperationError(space.w_ValueError, space.wrap("reduce only "
                "supported for binary functions"))
        dim = space.int_w(w_dim)
        assert isinstance(self, W_Ufunc2)
        obj = convert_to_array(space, w_obj)
        if dim >= len(obj.shape):
            raise OperationError(space.w_ValueError, space.wrap("axis(=%d) out of bounds" % dim))
        if isinstance(obj, Scalar):
            raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
                "on a scalar"))

        size = obj.size
        dtype = find_unaryop_result_dtype(
            space, obj.find_dtype(),
            promote_to_float=self.promote_to_float,
            promote_to_largest=promote_to_largest,
            promote_bools=True
        )
        shapelen = len(obj.shape)
        if self.identity is None and size == 0:
            raise operationerrfmt(space.w_ValueError, "zero-size array to "
                    "%s.reduce without identity", self.name)
        if shapelen > 1 and dim >= 0:
            res = self.do_axis_reduce(obj, dtype, dim)
            return space.wrap(res)
        scalarsig = ScalarSignature(dtype)
        sig = find_sig(ReduceSignature(self.func, self.name, dtype,
                                       scalarsig,
                                       obj.create_sig()), obj)
        frame = sig.create_frame(obj)
        if self.identity is None:
            value = sig.eval(frame, obj).convert_to(dtype)
            frame.next(shapelen)
        else:
            value = self.identity.convert_to(dtype)
        return self.reduce_loop(shapelen, sig, frame, value, obj, dtype)
示例#18
0
 def reduce(self, space, w_obj, multidim, promote_to_largest, axis,
            keepdims=False, out=None):
     from pypy.module.micronumpy.interp_numarray import convert_to_array, \
                                          Scalar, ReduceArray, W_NDimArray
     if self.argcount != 2:
         raise OperationError(space.w_ValueError, space.wrap("reduce only "
             "supported for binary functions"))
     assert isinstance(self, W_Ufunc2)
     obj = convert_to_array(space, w_obj)
     if axis >= len(obj.shape):
         raise OperationError(space.w_ValueError, space.wrap("axis(=%d) out of bounds" % axis))
     if isinstance(obj, Scalar):
         raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
             "on a scalar"))
     size = obj.size
     if self.comparison_func:
         dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         dtype = find_unaryop_result_dtype(
             space, obj.find_dtype(),
             promote_to_float=self.promote_to_float,
             promote_to_largest=promote_to_largest,
             promote_bools=True
         )
     shapelen = len(obj.shape)
     if self.identity is None and size == 0:
         raise operationerrfmt(space.w_ValueError, "zero-size array to "
                 "%s.reduce without identity", self.name)
     if shapelen > 1 and axis >= 0:
         if keepdims:
             shape = obj.shape[:axis] + [1] + obj.shape[axis + 1:]
         else:
             shape = obj.shape[:axis] + obj.shape[axis + 1:]
         if out:
             #Test for shape agreement
             if len(out.shape) > len(shape):
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter for reduction operation %s' +
                     ' has too many dimensions', self.name)
             elif len(out.shape) < len(shape):
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter for reduction operation %s' +
                     ' does not have enough dimensions', self.name)
             elif out.shape != shape:
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter shape mismatch, expecting [%s]' +
                     ' , got [%s]',
                     ",".join([str(x) for x in shape]),
                     ",".join([str(x) for x in out.shape]),
                     )
             #Test for dtype agreement, perhaps create an itermediate
             #if out.dtype != dtype:
             #    raise OperationError(space.w_TypeError, space.wrap(
             #        "mismatched  dtypes"))
             return self.do_axis_reduce(obj, out.find_dtype(), axis, out)
         else:
             result = W_NDimArray(shape, dtype)
             return self.do_axis_reduce(obj, dtype, axis, result)
     if out:
         if len(out.shape)>0:
             raise operationerrfmt(space.w_ValueError, "output parameter "
                           "for reduction operation %s has too many"
                           " dimensions",self.name)
         arr = ReduceArray(self.func, self.name, self.identity, obj,
                                                         out.find_dtype())
         val = loop.compute(arr)
         assert isinstance(out, Scalar)
         out.value = val
     else:
         arr = ReduceArray(self.func, self.name, self.identity, obj, dtype)
         val = loop.compute(arr)
     return val
示例#19
0
def where(space, w_arr, w_x, w_y):
    """where(condition, [x, y])

    Return elements, either from `x` or `y`, depending on `condition`.

    If only `condition` is given, return ``condition.nonzero()``.

    Parameters
    ----------
    condition : array_like, bool
        When True, yield `x`, otherwise yield `y`.
    x, y : array_like, optional
        Values from which to choose. `x` and `y` need to have the same
        shape as `condition`.

    Returns
    -------
    out : ndarray or tuple of ndarrays
        If both `x` and `y` are specified, the output array contains
        elements of `x` where `condition` is True, and elements from
        `y` elsewhere.

        If only `condition` is given, return the tuple
        ``condition.nonzero()``, the indices where `condition` is True.

    See Also
    --------
    nonzero, choose

    Notes
    -----
    If `x` and `y` are given and input arrays are 1-D, `where` is
    equivalent to::

        [xv if c else yv for (c,xv,yv) in zip(condition,x,y)]

    Examples
    --------
    >>> np.where([[True, False], [True, True]],
    ...          [[1, 2], [3, 4]],
    ...          [[9, 8], [7, 6]])
    array([[1, 8],
           [3, 4]])

    >>> np.where([[0, 1], [1, 0]])
    (array([0, 1]), array([1, 0]))

    >>> x = np.arange(9.).reshape(3, 3)
    >>> np.where( x > 5 )
    (array([2, 2, 2]), array([0, 1, 2]))
    >>> x[np.where( x > 3.0 )]               # Note: result is 1D.
    array([ 4.,  5.,  6.,  7.,  8.])
    >>> np.where(x < 5, x, -1)               # Note: broadcasting.
    array([[ 0.,  1.,  2.],
           [ 3.,  4., -1.],
           [-1., -1., -1.]])

    
    NOTE: support for not passing x and y is unsupported
    """
    arr = convert_to_array(space, w_arr)
    x = convert_to_array(space, w_x)
    y = convert_to_array(space, w_y)
    return WhereArray(space, arr, x, y)
示例#20
0
def where(space, w_arr, w_x, w_y):
    """where(condition, [x, y])

    Return elements, either from `x` or `y`, depending on `condition`.

    If only `condition` is given, return ``condition.nonzero()``.

    Parameters
    ----------
    condition : array_like, bool
        When True, yield `x`, otherwise yield `y`.
    x, y : array_like, optional
        Values from which to choose. `x` and `y` need to have the same
        shape as `condition`.

    Returns
    -------
    out : ndarray or tuple of ndarrays
        If both `x` and `y` are specified, the output array contains
        elements of `x` where `condition` is True, and elements from
        `y` elsewhere.

        If only `condition` is given, return the tuple
        ``condition.nonzero()``, the indices where `condition` is True.

    See Also
    --------
    nonzero, choose

    Notes
    -----
    If `x` and `y` are given and input arrays are 1-D, `where` is
    equivalent to::

        [xv if c else yv for (c,xv,yv) in zip(condition,x,y)]

    Examples
    --------
    >>> np.where([[True, False], [True, True]],
    ...          [[1, 2], [3, 4]],
    ...          [[9, 8], [7, 6]])
    array([[1, 8],
           [3, 4]])

    >>> np.where([[0, 1], [1, 0]])
    (array([0, 1]), array([1, 0]))

    >>> x = np.arange(9.).reshape(3, 3)
    >>> np.where( x > 5 )
    (array([2, 2, 2]), array([0, 1, 2]))
    >>> x[np.where( x > 3.0 )]               # Note: result is 1D.
    array([ 4.,  5.,  6.,  7.,  8.])
    >>> np.where(x < 5, x, -1)               # Note: broadcasting.
    array([[ 0.,  1.,  2.],
           [ 3.,  4., -1.],
           [-1., -1., -1.]])

    
    NOTE: support for not passing x and y is unsupported
    """
    arr = convert_to_array(space, w_arr)
    x = convert_to_array(space, w_x)
    y = convert_to_array(space, w_y)
    return WhereArray(space, arr, x, y)
示例#21
0
 def reduce(self, space, w_obj, multidim, promote_to_largest, axis,
            keepdims=False, out=None):
     from pypy.module.micronumpy.interp_numarray import convert_to_array, \
                                          Scalar, ReduceArray, W_NDimArray
     if self.argcount != 2:
         raise OperationError(space.w_ValueError, space.wrap("reduce only "
             "supported for binary functions"))
     assert isinstance(self, W_Ufunc2)
     obj = convert_to_array(space, w_obj)
     if axis >= len(obj.shape):
         raise OperationError(space.w_ValueError, space.wrap("axis(=%d) out of bounds" % axis))
     if isinstance(obj, Scalar):
         raise OperationError(space.w_TypeError, space.wrap("cannot reduce "
             "on a scalar"))
     size = obj.size
     if self.comparison_func:
         dtype = interp_dtype.get_dtype_cache(space).w_booldtype
     else:
         dtype = find_unaryop_result_dtype(
             space, obj.find_dtype(),
             promote_to_float=self.promote_to_float,
             promote_to_largest=promote_to_largest,
             promote_bools=True
         )
     shapelen = len(obj.shape)
     if self.identity is None and size == 0:
         raise operationerrfmt(space.w_ValueError, "zero-size array to "
                 "%s.reduce without identity", self.name)
     if shapelen > 1 and axis >= 0:
         if keepdims:
             shape = obj.shape[:axis] + [1] + obj.shape[axis + 1:]
         else:
             shape = obj.shape[:axis] + obj.shape[axis + 1:]
         if out:
             #Test for shape agreement
             if len(out.shape) > len(shape):
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter for reduction operation %s' +
                     ' has too many dimensions', self.name)
             elif len(out.shape) < len(shape):
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter for reduction operation %s' +
                     ' does not have enough dimensions', self.name)
             elif out.shape != shape:
                 raise operationerrfmt(space.w_ValueError,
                     'output parameter shape mismatch, expecting [%s]' +
                     ' , got [%s]',
                     ",".join([str(x) for x in shape]),
                     ",".join([str(x) for x in out.shape]),
                     )
             #Test for dtype agreement, perhaps create an itermediate
             #if out.dtype != dtype:
             #    raise OperationError(space.w_TypeError, space.wrap(
             #        "mismatched  dtypes"))
             return self.do_axis_reduce(obj, out.find_dtype(), axis, out)
         else:
             result = W_NDimArray(shape, dtype)
             return self.do_axis_reduce(obj, dtype, axis, result)
     if out:
         if len(out.shape)>0:
             raise operationerrfmt(space.w_ValueError, "output parameter "
                           "for reduction operation %s has too many"
                           " dimensions",self.name)
         arr = ReduceArray(self.func, self.name, self.identity, obj,
                                                         out.find_dtype())
         val = loop.compute(arr)
         assert isinstance(out, Scalar)
         out.value = val
     else:
         arr = ReduceArray(self.func, self.name, self.identity, obj, dtype)
         val = loop.compute(arr)
     return val