File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib64/python2.7/site-packages/numpy/lib

opt / alt / python27 / lib64 / python2.7 / site-packages / numpy / lib /

📁 ..
📄 __init__.py(1.16 KB)
📄 __init__.pyc(1.29 KB)
📄 __init__.pyo(1.29 KB)
📄 _datasource.py(20.77 KB)
📄 _datasource.pyc(21.32 KB)
📄 _datasource.pyo(21.32 KB)
📄 _iotools.py(31.31 KB)
📄 _iotools.pyc(29.52 KB)
📄 _iotools.pyo(29.52 KB)
📄 _version.py(4.75 KB)
📄 _version.pyc(5.65 KB)
📄 _version.pyo(5.65 KB)
📄 arraypad.py(50.86 KB)
📄 arraypad.pyc(48.4 KB)
📄 arraypad.pyo(48.4 KB)
📄 arraysetops.py(13.49 KB)
📄 arraysetops.pyc(13.37 KB)
📄 arraysetops.pyo(13.37 KB)
📄 arrayterator.py(7.03 KB)
📄 arrayterator.pyc(7.68 KB)
📄 arrayterator.pyo(7.68 KB)
📄 financial.py(23.28 KB)
📄 financial.pyc(24.2 KB)
📄 financial.pyo(24.2 KB)
📄 format.py(27.57 KB)
📄 format.pyc(25.03 KB)
📄 format.pyo(25.03 KB)
📄 function_base.py(146.99 KB)
📄 function_base.pyc(133.09 KB)
📄 function_base.pyo(133.09 KB)
📄 index_tricks.py(25.59 KB)
📄 index_tricks.pyc(26.72 KB)
📄 index_tricks.pyo(26.72 KB)
📄 info.py(6.35 KB)
📄 info.pyc(6.6 KB)
📄 info.pyo(6.6 KB)
📄 nanfunctions.py(45.4 KB)
📄 nanfunctions.pyc(44.28 KB)
📄 nanfunctions.pyo(44.28 KB)
📄 npyio.py(69.74 KB)
📄 npyio.pyc(57.01 KB)
📄 npyio.pyo(57.01 KB)
📄 polynomial.py(37.12 KB)
📄 polynomial.pyc(39.51 KB)
📄 polynomial.pyo(39.51 KB)
📄 recfunctions.py(34.19 KB)
📄 recfunctions.pyc(30.43 KB)
📄 recfunctions.pyo(30.43 KB)
📄 scimath.py(13.75 KB)
📄 scimath.pyc(15.79 KB)
📄 scimath.pyo(15.79 KB)
📄 setup.py(379 B)
📄 setup.pyc(755 B)
📄 setup.pyo(755 B)
📄 shape_base.py(24.97 KB)
📄 shape_base.pyc(26.44 KB)
📄 shape_base.pyo(26.44 KB)
📄 stride_tricks.py(6.67 KB)
📄 stride_tricks.pyc(6.93 KB)
📄 stride_tricks.pyo(6.93 KB)
📁 tests
📄 twodim_base.py(26.27 KB)
📄 twodim_base.pyc(29.16 KB)
📄 twodim_base.pyo(29.16 KB)
📄 type_check.py(15.43 KB)
📄 type_check.pyc(16.89 KB)
📄 type_check.pyo(16.89 KB)
📄 ufunclike.py(4.73 KB)
📄 ufunclike.pyc(5.51 KB)
📄 ufunclike.pyo(5.51 KB)
📄 user_array.py(7.81 KB)
📄 user_array.pyc(16.28 KB)
📄 user_array.pyo(16.28 KB)
📄 utils.py(34.18 KB)
📄 utils.pyc(30.22 KB)
📄 utils.pyo(30.22 KB)

Editing: user_array.py

"""
Standard container-class for easy multiple-inheritance.

Try to inherit from the ndarray instead of using this class as this is not
complete.

"""
from __future__ import division, absolute_import, print_function

from numpy.core import (
    array, asarray, absolute, add, subtract, multiply, divide,
    remainder, power, left_shift, right_shift, bitwise_and, bitwise_or,
    bitwise_xor, invert, less, less_equal, not_equal, equal, greater,
    greater_equal, shape, reshape, arange, sin, sqrt, transpose
)
from numpy.compat import long

class container(object):
    """
    container(data, dtype=None, copy=True)

Standard container-class for easy multiple-inheritance.

Methods
    -------
    copy
    tostring
    byteswap
    astype

"""
    def __init__(self, data, dtype=None, copy=True):
        self.array = array(data, dtype, copy=copy)

def __repr__(self):
        if len(self.shape) > 0:
            return self.__class__.__name__ + repr(self.array)[len("array"):]
        else:
            return self.__class__.__name__ + "(" + repr(self.array) + ")"

def __array__(self, t=None):
        if t:
            return self.array.astype(t)
        return self.array

# Array as sequence
    def __len__(self):
        return len(self.array)

def __getitem__(self, index):
        return self._rc(self.array[index])

def __getslice__(self, i, j):
        return self._rc(self.array[i:j])

def __setitem__(self, index, value):
        self.array[index] = asarray(value, self.dtype)

def __setslice__(self, i, j, value):
        self.array[i:j] = asarray(value, self.dtype)

def __abs__(self):
        return self._rc(absolute(self.array))

def __neg__(self):
        return self._rc(-self.array)

def __add__(self, other):
        return self._rc(self.array + asarray(other))

__radd__ = __add__

def __iadd__(self, other):
        add(self.array, other, self.array)
        return self

def __sub__(self, other):
        return self._rc(self.array - asarray(other))

def __rsub__(self, other):
        return self._rc(asarray(other) - self.array)

def __isub__(self, other):
        subtract(self.array, other, self.array)
        return self

def __mul__(self, other):
        return self._rc(multiply(self.array, asarray(other)))

__rmul__ = __mul__

def __imul__(self, other):
        multiply(self.array, other, self.array)
        return self

def __div__(self, other):
        return self._rc(divide(self.array, asarray(other)))

def __rdiv__(self, other):
        return self._rc(divide(asarray(other), self.array))

def __idiv__(self, other):
        divide(self.array, other, self.array)
        return self

def __mod__(self, other):
        return self._rc(remainder(self.array, other))

def __rmod__(self, other):
        return self._rc(remainder(other, self.array))

def __imod__(self, other):
        remainder(self.array, other, self.array)
        return self

def __divmod__(self, other):
        return (self._rc(divide(self.array, other)),
                self._rc(remainder(self.array, other)))

def __rdivmod__(self, other):
        return (self._rc(divide(other, self.array)),
                self._rc(remainder(other, self.array)))

def __pow__(self, other):
        return self._rc(power(self.array, asarray(other)))

def __rpow__(self, other):
        return self._rc(power(asarray(other), self.array))

def __ipow__(self, other):
        power(self.array, other, self.array)
        return self

def __lshift__(self, other):
        return self._rc(left_shift(self.array, other))

def __rshift__(self, other):
        return self._rc(right_shift(self.array, other))

def __rlshift__(self, other):
        return self._rc(left_shift(other, self.array))

def __rrshift__(self, other):
        return self._rc(right_shift(other, self.array))

def __ilshift__(self, other):
        left_shift(self.array, other, self.array)
        return self

def __irshift__(self, other):
        right_shift(self.array, other, self.array)
        return self

def __and__(self, other):
        return self._rc(bitwise_and(self.array, other))

def __rand__(self, other):
        return self._rc(bitwise_and(other, self.array))

def __iand__(self, other):
        bitwise_and(self.array, other, self.array)
        return self

def __xor__(self, other):
        return self._rc(bitwise_xor(self.array, other))

def __rxor__(self, other):
        return self._rc(bitwise_xor(other, self.array))

def __ixor__(self, other):
        bitwise_xor(self.array, other, self.array)
        return self

def __or__(self, other):
        return self._rc(bitwise_or(self.array, other))

def __ror__(self, other):
        return self._rc(bitwise_or(other, self.array))

def __ior__(self, other):
        bitwise_or(self.array, other, self.array)
        return self

def __pos__(self):
        return self._rc(self.array)

def __invert__(self):
        return self._rc(invert(self.array))

def _scalarfunc(self, func):
        if len(self.shape) == 0:
            return func(self[0])
        else:
            raise TypeError(
                "only rank-0 arrays can be converted to Python scalars.")

def __complex__(self):
        return self._scalarfunc(complex)

def __float__(self):
        return self._scalarfunc(float)

def __int__(self):
        return self._scalarfunc(int)

def __long__(self):
        return self._scalarfunc(long)

def __hex__(self):
        return self._scalarfunc(hex)

def __oct__(self):
        return self._scalarfunc(oct)

def __lt__(self, other):
        return self._rc(less(self.array, other))

def __le__(self, other):
        return self._rc(less_equal(self.array, other))

def __eq__(self, other):
        return self._rc(equal(self.array, other))

def __ne__(self, other):
        return self._rc(not_equal(self.array, other))

def __gt__(self, other):
        return self._rc(greater(self.array, other))

def __ge__(self, other):
        return self._rc(greater_equal(self.array, other))

def copy(self):
        ""
        return self._rc(self.array.copy())

def tostring(self):
        ""
        return self.array.tostring()

def byteswap(self):
        ""
        return self._rc(self.array.byteswap())

def astype(self, typecode):
        ""
        return self._rc(self.array.astype(typecode))

def _rc(self, a):
        if len(shape(a)) == 0:
            return a
        else:
            return self.__class__(a)

def __array_wrap__(self, *args):
        return self.__class__(args[0])

def __setattr__(self, attr, value):
        if attr == 'array':
            object.__setattr__(self, attr, value)
            return
        try:
            self.array.__setattr__(attr, value)
        except AttributeError:
            object.__setattr__(self, attr, value)

# Only called after other approaches fail.
    def __getattr__(self, attr):
        if (attr == 'array'):
            return object.__getattribute__(self, attr)
        return self.array.__getattribute__(attr)

#############################################################
# Test of class container
#############################################################
if __name__ == '__main__':
    temp = reshape(arange(10000), (100, 100))

ua = container(temp)
    # new object created begin test
    print(dir(ua))
    print(shape(ua), ua.shape)  # I have changed Numeric.py

ua_small = ua[:3, :5]
    print(ua_small)
    # this did not change ua[0,0], which is not normal behavior
    ua_small[0, 0] = 10
    print(ua_small[0, 0], ua[0, 0])
    print(sin(ua_small) / 3. * 6. + sqrt(ua_small ** 2))
    print(less(ua_small, 103), type(less(ua_small, 103)))
    print(type(ua_small * reshape(arange(15), shape(ua_small))))
    print(reshape(ua_small, (5, 3)))
    print(transpose(ua_small))

Hackfut Security File Manager

Editing: user_array.py

Upload File

Create Folder