1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
from numarrayall import *
import libnumeric
numarray_nonzero = nonzero
numarray_put = put
numarray_putmask = putmask
numarray_take = take
numarray_ones = ones
numarray_zeros = zeros
def nonzero(a):
"""nonzero() returns either an index array or a tuple of index
arrays corresponding to the indices where the values of an array
are not equal to zero.
This is the Numeric compatible version of nonzero() supplied by
numarray.numeric. It differs from numarray.nonzero() in the
handling of 1D arrays. numarray.nonzero() always returns a tuple;
Numeric.nonzero() returns a tuple when the number of dimensions of
the array is not one.
"""
nz = numarray_nonzero(a)
if len(nz) > 1:
return nz
elif len(nz) == 1:
return nz[0]
else:
return nz
def ones(shape, typecode='l', savespace=0):
return numarray_ones(shape, typecode)
def zeros(shape, typecode='l', savespace=0):
return numarray_zeros(shape, typecode)
arraytype = NumArray
from libnumeric import take, histogram # , transpose
def repeat(a, repeats, axis=0):
"""repeat elements of a repeats times along axis
repeats is a sequence of length a.shape[axis]
telling how many times to repeat each element.
If repeats is an integer, it is interpreted as
a tuple of length a.shape[axis] containing repeats.
The argument a can be anything array(a) will accept.
"""
a = array(a, copy=0)
s = a.shape
if isinstance(repeats, types.IntType):
repeats = tuple([repeats]*(s[axis]))
if len(repeats) != s[axis]:
raise ValueError, "repeat requires second argument integer or of length of a.shape[axis]."
d = libnumeric.repeat(a, repeats, axis)
return d
#add extra intelligence to the basic C functions
def concatenate(a, axis=0):
"""concatenate(a, axis=0) joins the tuple of sequences in a into a single
NumPy array.
"""
if axis == 0:
return libnumeric.concatenate(a)
else:
new_list = []
for m in a:
new_list.append(swapaxes(m, axis, 0))
return swapaxes(libnumeric.concatenate(new_list), axis, 0)
def sort(a, axis=-1):
"""sort(a,axis=-1) returns array with elements sorted along given axis.
"""
a = array(a, copy=0)
n = len(a.shape)
if axis < 0: axis += n
if axis < 0 or axis >= n:
raise ValueError, "sort axis argument out of bounds"
if axis != n-1: a = swapaxes(a, axis, n-1)
s = libnumeric.sort(a)
if axis != n-1: s = swapaxes(s, axis, -1)
return s
def argsort(a, axis=-1):
"""argsort(a,axis=-1) return the indices into a of the sorted array
along the given axis, so that take(a,result,axis) is the sorted array.
"""
a = array(a, copy=0)
n = len(a.shape)
if axis < 0: axis += n
if axis < 0 or axis >= n:
raise ValueError, "argsort axis argument out of bounds"
if axis != n-1: a = swapaxes(a, axis, n-1)
s = libnumeric.argsort(a)
if axis != n-1: s = swapaxes(s, axis, -1)
return s
def argmax(a, axis=-1):
"""argmax(a,axis=-1) returns the indices to the maximum value of the
1-D arrays along the given axis.
"""
a = array(a, copy=0)
n = len(a.shape)
if axis < 0: axis += n
if axis < 0 or axis >= n:
raise ValueError, "argmax axis argument out of bounds"
if axis != n-1: a = swapaxes(a, axis, n-1)
s = libnumeric.argmax(a)
if axis != n-1: s = swapaxes(s, axis, -1)
return s
def argmin(a, axis=-1):
"""argmin(a,axis=-1) returns the indices to the minimum value of the
1-D arrays along the given axis.
"""
a = -array(a, copy=0)
n = len(a.shape)
if axis < 0: axis += n
if axis < 0 or axis >= n:
raise ValueError, "argmin axis argument out of bounds"
if axis != n-1: a = swapaxes(a, axis, n-1)
s = libnumeric.argmax(a)
if axis != n-1: s = swapaxes(s, axis, -1)
return s
def resize(a, new_shape):
"""resize(a,new_shape) returns a new array with the specified shape.
The original array's total size can be any size.
"""
a = ravel(a)
if not len(a): return zeros(new_shape, a.typecode())
total_size = multiply.reduce(new_shape)
n_copies = int(total_size / len(a))
extra = total_size % len(a)
if extra != 0:
n_copies = n_copies+1
extra = len(a)-extra
a = concatenate( (a,)*n_copies)
if extra > 0:
a = a[:-extra]
return reshape(a, new_shape)
def put (a, ind, v):
"""put(a, ind, v) results in a[n] = v[n] for all n in ind
If v is shorter than mask it will be repeated as necessary.
In particular v can be a scalar or length 1 array.
The routine put is the equivalent of the following (although the loop
is in C for speed):
ind = array(indices, copy=0)
v = array(values, copy=0).astype(a, typecode())
for i in ind: a.flat[i] = v[i]
a must be a contiguous Numeric array.
"""
libnumeric.put (a, ind, array(v, copy=0).astype(a.typecode()))
def putmask (a, mask, v):
"""putmask(a, mask, v) results in a = v for all places mask is true.
If v is shorter than mask it will be repeated as necessary.
In particular v can be a scalar or length 1 array.
"""
tc = a.typecode()
mask = asarray(mask).astype(Int)
v = array(v, copy=0).astype(tc)
libnumeric.putmask (a, mask, v)
|
