| |
- Method resolution order:
- matrix
- ndarray
- builtins.object
Methods defined here:
- __array_finalize__(self, obj)
- None.
- __getitem__(self, index)
- Return self[key].
- __imul__(self, other)
- Return self*=value.
- __ipow__(self, other)
- Return self**=value.
- __mul__(self, other)
- Return self*value.
- __pow__(self, other)
- Return pow(self, value, mod).
- __rmul__(self, other)
- Return value*self.
- __rpow__(self, other)
- Return pow(value, self, mod).
- all(self, axis=None, out=None)
- Test whether all matrix elements along a given axis evaluate to True.
Parameters
----------
See `numpy.all` for complete descriptions
See Also
--------
numpy.all
Notes
-----
This is the same as `ndarray.all`, but it returns a `matrix` object.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> y = x[0]; y
matrix([[0, 1, 2, 3]])
>>> (x == y)
matrix([[ True, True, True, True],
[False, False, False, False],
[False, False, False, False]])
>>> (x == y).all()
False
>>> (x == y).all(0)
matrix([[False, False, False, False]])
>>> (x == y).all(1)
matrix([[ True],
[False],
[False]])
- any(self, axis=None, out=None)
- Test whether any array element along a given axis evaluates to True.
Refer to `numpy.any` for full documentation.
Parameters
----------
axis : int, optional
Axis along which logical OR is performed
out : ndarray, optional
Output to existing array instead of creating new one, must have
same shape as expected output
Returns
-------
any : bool, ndarray
Returns a single bool if `axis` is ``None``; otherwise,
returns `ndarray`
- argmax(self, axis=None, out=None)
- Indexes of the maximum values along an axis.
Return the indexes of the first occurrences of the maximum values
along the specified axis. If axis is None, the index is for the
flattened matrix.
Parameters
----------
See `numpy.argmax` for complete descriptions
See Also
--------
numpy.argmax
Notes
-----
This is the same as `ndarray.argmax`, but returns a `matrix` object
where `ndarray.argmax` would return an `ndarray`.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.argmax()
11
>>> x.argmax(0)
matrix([[2, 2, 2, 2]])
>>> x.argmax(1)
matrix([[3],
[3],
[3]])
- argmin(self, axis=None, out=None)
- Indexes of the minimum values along an axis.
Return the indexes of the first occurrences of the minimum values
along the specified axis. If axis is None, the index is for the
flattened matrix.
Parameters
----------
See `numpy.argmin` for complete descriptions.
See Also
--------
numpy.argmin
Notes
-----
This is the same as `ndarray.argmin`, but returns a `matrix` object
where `ndarray.argmin` would return an `ndarray`.
Examples
--------
>>> x = -np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, -1, -2, -3],
[ -4, -5, -6, -7],
[ -8, -9, -10, -11]])
>>> x.argmin()
11
>>> x.argmin(0)
matrix([[2, 2, 2, 2]])
>>> x.argmin(1)
matrix([[3],
[3],
[3]])
- flatten(self, order='C')
- Return a flattened copy of the matrix.
All `N` elements of the matrix are placed into a single row.
Parameters
----------
order : {'C', 'F', 'A', 'K'}, optional
'C' means to flatten in row-major (C-style) order. 'F' means to
flatten in column-major (Fortran-style) order. 'A' means to
flatten in column-major order if `m` is Fortran *contiguous* in
memory, row-major order otherwise. 'K' means to flatten `m` in
the order the elements occur in memory. The default is 'C'.
Returns
-------
y : matrix
A copy of the matrix, flattened to a `(1, N)` matrix where `N`
is the number of elements in the original matrix.
See Also
--------
ravel : Return a flattened array.
flat : A 1-D flat iterator over the matrix.
Examples
--------
>>> m = np.matrix([[1,2], [3,4]])
>>> m.flatten()
matrix([[1, 2, 3, 4]])
>>> m.flatten('F')
matrix([[1, 3, 2, 4]])
- getA = A(self)
- Return `self` as an `ndarray` object.
Equivalent to ``np.asarray(self)``.
Parameters
----------
None
Returns
-------
ret : ndarray
`self` as an `ndarray`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.getA()
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
- getA1 = A1(self)
- Return `self` as a flattened `ndarray`.
Equivalent to ``np.asarray(x).ravel()``
Parameters
----------
None
Returns
-------
ret : ndarray
`self`, 1-D, as an `ndarray`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.getA1()
array([ 0, 1, 2, ..., 9, 10, 11])
- getH = H(self)
- Returns the (complex) conjugate transpose of `self`.
Equivalent to ``np.transpose(self)`` if `self` is real-valued.
Parameters
----------
None
Returns
-------
ret : matrix object
complex conjugate transpose of `self`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4)))
>>> z = x - 1j*x; z
matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j],
[ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j],
[ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]])
>>> z.getH()
matrix([[ 0. -0.j, 4. +4.j, 8. +8.j],
[ 1. +1.j, 5. +5.j, 9. +9.j],
[ 2. +2.j, 6. +6.j, 10.+10.j],
[ 3. +3.j, 7. +7.j, 11.+11.j]])
- getI = I(self)
- Returns the (multiplicative) inverse of invertible `self`.
Parameters
----------
None
Returns
-------
ret : matrix object
If `self` is non-singular, `ret` is such that ``ret * self`` ==
``self * ret`` == ``np.matrix(np.eye(self[0,:].size)`` all return
``True``.
Raises
------
numpy.linalg.LinAlgError: Singular matrix
If `self` is singular.
See Also
--------
linalg.inv
Examples
--------
>>> m = np.matrix('[1, 2; 3, 4]'); m
matrix([[1, 2],
[3, 4]])
>>> m.getI()
matrix([[-2. , 1. ],
[ 1.5, -0.5]])
>>> m.getI() * m
matrix([[ 1., 0.], # may vary
[ 0., 1.]])
- getT = T(self)
- Returns the transpose of the matrix.
Does *not* conjugate! For the complex conjugate transpose, use ``.H``.
Parameters
----------
None
Returns
-------
ret : matrix object
The (non-conjugated) transpose of the matrix.
See Also
--------
transpose, getH
Examples
--------
>>> m = np.matrix('[1, 2; 3, 4]')
>>> m
matrix([[1, 2],
[3, 4]])
>>> m.getT()
matrix([[1, 3],
[2, 4]])
- max(self, axis=None, out=None)
- Return the maximum value along an axis.
Parameters
----------
See `amax` for complete descriptions
See Also
--------
amax, ndarray.max
Notes
-----
This is the same as `ndarray.max`, but returns a `matrix` object
where `ndarray.max` would return an ndarray.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.max()
11
>>> x.max(0)
matrix([[ 8, 9, 10, 11]])
>>> x.max(1)
matrix([[ 3],
[ 7],
[11]])
- mean(self, axis=None, dtype=None, out=None)
- Returns the average of the matrix elements along the given axis.
Refer to `numpy.mean` for full documentation.
See Also
--------
numpy.mean
Notes
-----
Same as `ndarray.mean` except that, where that returns an `ndarray`,
this returns a `matrix` object.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3, 4)))
>>> x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.mean()
5.5
>>> x.mean(0)
matrix([[4., 5., 6., 7.]])
>>> x.mean(1)
matrix([[ 1.5],
[ 5.5],
[ 9.5]])
- min(self, axis=None, out=None)
- Return the minimum value along an axis.
Parameters
----------
See `amin` for complete descriptions.
See Also
--------
amin, ndarray.min
Notes
-----
This is the same as `ndarray.min`, but returns a `matrix` object
where `ndarray.min` would return an ndarray.
Examples
--------
>>> x = -np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, -1, -2, -3],
[ -4, -5, -6, -7],
[ -8, -9, -10, -11]])
>>> x.min()
-11
>>> x.min(0)
matrix([[ -8, -9, -10, -11]])
>>> x.min(1)
matrix([[ -3],
[ -7],
[-11]])
- prod(self, axis=None, dtype=None, out=None)
- Return the product of the array elements over the given axis.
Refer to `prod` for full documentation.
See Also
--------
prod, ndarray.prod
Notes
-----
Same as `ndarray.prod`, except, where that returns an `ndarray`, this
returns a `matrix` object instead.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.prod()
0
>>> x.prod(0)
matrix([[ 0, 45, 120, 231]])
>>> x.prod(1)
matrix([[ 0],
[ 840],
[7920]])
- ptp(self, axis=None, out=None)
- Peak-to-peak (maximum - minimum) value along the given axis.
Refer to `numpy.ptp` for full documentation.
See Also
--------
numpy.ptp
Notes
-----
Same as `ndarray.ptp`, except, where that would return an `ndarray` object,
this returns a `matrix` object.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.ptp()
11
>>> x.ptp(0)
matrix([[8, 8, 8, 8]])
>>> x.ptp(1)
matrix([[3],
[3],
[3]])
- ravel(self, order='C')
- Return a flattened matrix.
Refer to `numpy.ravel` for more documentation.
Parameters
----------
order : {'C', 'F', 'A', 'K'}, optional
The elements of `m` are read using this index order. 'C' means to
index the elements in C-like order, with the last axis index
changing fastest, back to the first axis index changing slowest.
'F' means to index the elements in Fortran-like index order, with
the first index changing fastest, and the last index changing
slowest. Note that the 'C' and 'F' options take no account of the
memory layout of the underlying array, and only refer to the order
of axis indexing. 'A' means to read the elements in Fortran-like
index order if `m` is Fortran *contiguous* in memory, C-like order
otherwise. 'K' means to read the elements in the order they occur
in memory, except for reversing the data when strides are negative.
By default, 'C' index order is used.
Returns
-------
ret : matrix
Return the matrix flattened to shape `(1, N)` where `N`
is the number of elements in the original matrix.
A copy is made only if necessary.
See Also
--------
matrix.flatten : returns a similar output matrix but always a copy
matrix.flat : a flat iterator on the array.
numpy.ravel : related function which returns an ndarray
- squeeze(self, axis=None)
- Return a possibly reshaped matrix.
Refer to `numpy.squeeze` for more documentation.
Parameters
----------
axis : None or int or tuple of ints, optional
Selects a subset of the single-dimensional entries in the shape.
If an axis is selected with shape entry greater than one,
an error is raised.
Returns
-------
squeezed : matrix
The matrix, but as a (1, N) matrix if it had shape (N, 1).
See Also
--------
numpy.squeeze : related function
Notes
-----
If `m` has a single column then that column is returned
as the single row of a matrix. Otherwise `m` is returned.
The returned matrix is always either `m` itself or a view into `m`.
Supplying an axis keyword argument will not affect the returned matrix
but it may cause an error to be raised.
Examples
--------
>>> c = np.matrix([[1], [2]])
>>> c
matrix([[1],
[2]])
>>> c.squeeze()
matrix([[1, 2]])
>>> r = c.T
>>> r
matrix([[1, 2]])
>>> r.squeeze()
matrix([[1, 2]])
>>> m = np.matrix([[1, 2], [3, 4]])
>>> m.squeeze()
matrix([[1, 2],
[3, 4]])
- std(self, axis=None, dtype=None, out=None, ddof=0)
- Return the standard deviation of the array elements along the given axis.
Refer to `numpy.std` for full documentation.
See Also
--------
numpy.std
Notes
-----
This is the same as `ndarray.std`, except that where an `ndarray` would
be returned, a `matrix` object is returned instead.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3, 4)))
>>> x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.std()
3.4520525295346629 # may vary
>>> x.std(0)
matrix([[ 3.26598632, 3.26598632, 3.26598632, 3.26598632]]) # may vary
>>> x.std(1)
matrix([[ 1.11803399],
[ 1.11803399],
[ 1.11803399]])
- sum(self, axis=None, dtype=None, out=None)
- Returns the sum of the matrix elements, along the given axis.
Refer to `numpy.sum` for full documentation.
See Also
--------
numpy.sum
Notes
-----
This is the same as `ndarray.sum`, except that where an `ndarray` would
be returned, a `matrix` object is returned instead.
Examples
--------
>>> x = np.matrix([[1, 2], [4, 3]])
>>> x.sum()
10
>>> x.sum(axis=1)
matrix([[3],
[7]])
>>> x.sum(axis=1, dtype='float')
matrix([[3.],
[7.]])
>>> out = np.zeros((2, 1), dtype='float')
>>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))
matrix([[3.],
[7.]])
- tolist(self)
- Return the matrix as a (possibly nested) list.
See `ndarray.tolist` for full documentation.
See Also
--------
ndarray.tolist
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.tolist()
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
- var(self, axis=None, dtype=None, out=None, ddof=0)
- Returns the variance of the matrix elements, along the given axis.
Refer to `numpy.var` for full documentation.
See Also
--------
numpy.var
Notes
-----
This is the same as `ndarray.var`, except that where an `ndarray` would
be returned, a `matrix` object is returned instead.
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3, 4)))
>>> x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.var()
11.916666666666666
>>> x.var(0)
matrix([[ 10.66666667, 10.66666667, 10.66666667, 10.66666667]]) # may vary
>>> x.var(1)
matrix([[1.25],
[1.25],
[1.25]])
Static methods defined here:
- __new__(subtype, data, dtype=None, copy=True)
- Create and return a new object. See help(type) for accurate signature.
Data descriptors defined here:
- A
- Return `self` as an `ndarray` object.
Equivalent to ``np.asarray(self)``.
Parameters
----------
None
Returns
-------
ret : ndarray
`self` as an `ndarray`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.getA()
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
- A1
- Return `self` as a flattened `ndarray`.
Equivalent to ``np.asarray(x).ravel()``
Parameters
----------
None
Returns
-------
ret : ndarray
`self`, 1-D, as an `ndarray`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.getA1()
array([ 0, 1, 2, ..., 9, 10, 11])
- H
- Returns the (complex) conjugate transpose of `self`.
Equivalent to ``np.transpose(self)`` if `self` is real-valued.
Parameters
----------
None
Returns
-------
ret : matrix object
complex conjugate transpose of `self`
Examples
--------
>>> x = np.matrix(np.arange(12).reshape((3,4)))
>>> z = x - 1j*x; z
matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j],
[ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j],
[ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]])
>>> z.getH()
matrix([[ 0. -0.j, 4. +4.j, 8. +8.j],
[ 1. +1.j, 5. +5.j, 9. +9.j],
[ 2. +2.j, 6. +6.j, 10.+10.j],
[ 3. +3.j, 7. +7.j, 11.+11.j]])
- I
- Returns the (multiplicative) inverse of invertible `self`.
Parameters
----------
None
Returns
-------
ret : matrix object
If `self` is non-singular, `ret` is such that ``ret * self`` ==
``self * ret`` == ``np.matrix(np.eye(self[0,:].size)`` all return
``True``.
Raises
------
numpy.linalg.LinAlgError: Singular matrix
If `self` is singular.
See Also
--------
linalg.inv
Examples
--------
>>> m = np.matrix('[1, 2; 3, 4]'); m
matrix([[1, 2],
[3, 4]])
>>> m.getI()
matrix([[-2. , 1. ],
[ 1.5, -0.5]])
>>> m.getI() * m
matrix([[ 1., 0.], # may vary
[ 0., 1.]])
- T
- Returns the transpose of the matrix.
Does *not* conjugate! For the complex conjugate transpose, use ``.H``.
Parameters
----------
None
Returns
-------
ret : matrix object
The (non-conjugated) transpose of the matrix.
See Also
--------
transpose, getH
Examples
--------
>>> m = np.matrix('[1, 2; 3, 4]')
>>> m
matrix([[1, 2],
[3, 4]])
>>> m.getT()
matrix([[1, 3],
[2, 4]])
- __dict__
- dictionary for instance variables (if defined)
Data and other attributes defined here:
- __array_priority__ = 10.0
Methods inherited from ndarray:
- __abs__(self, /)
- abs(self)
- __add__(self, value, /)
- Return self+value.
- __and__(self, value, /)
- Return self&value.
- __array__(...)
- a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
Returns either a new reference to self if dtype is not given or a new array
of provided data type if dtype is different from the current dtype of the
array.
- __array_function__(...)
- __array_prepare__(...)
- a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
- __array_ufunc__(...)
- __array_wrap__(...)
- a.__array_wrap__(obj) -> Object of same type as ndarray object a.
- __bool__(self, /)
- self != 0
- __complex__(...)
- __contains__(self, key, /)
- Return key in self.
- __copy__(...)
- a.__copy__()
Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
Equivalent to ``a.copy(order='K')``.
- __deepcopy__(...)
- a.__deepcopy__(memo, /) -> Deep copy of array.
Used if :func:`copy.deepcopy` is called on an array.
- __delitem__(self, key, /)
- Delete self[key].
- __divmod__(self, value, /)
- Return divmod(self, value).
- __eq__(self, value, /)
- Return self==value.
- __float__(self, /)
- float(self)
- __floordiv__(self, value, /)
- Return self//value.
- __format__(...)
- Default object formatter.
- __ge__(self, value, /)
- Return self>=value.
- __gt__(self, value, /)
- Return self>value.
- __iadd__(self, value, /)
- Return self+=value.
- __iand__(self, value, /)
- Return self&=value.
- __ifloordiv__(self, value, /)
- Return self//=value.
- __ilshift__(self, value, /)
- Return self<<=value.
- __imatmul__(self, value, /)
- Return self@=value.
- __imod__(self, value, /)
- Return self%=value.
- __index__(self, /)
- Return self converted to an integer, if self is suitable for use as an index into a list.
- __int__(self, /)
- int(self)
- __invert__(self, /)
- ~self
- __ior__(self, value, /)
- Return self|=value.
- __irshift__(self, value, /)
- Return self>>=value.
- __isub__(self, value, /)
- Return self-=value.
- __iter__(self, /)
- Implement iter(self).
- __itruediv__(self, value, /)
- Return self/=value.
- __ixor__(self, value, /)
- Return self^=value.
- __le__(self, value, /)
- Return self<=value.
- __len__(self, /)
- Return len(self).
- __lshift__(self, value, /)
- Return self<<value.
- __lt__(self, value, /)
- Return self<value.
- __matmul__(self, value, /)
- Return self@value.
- __mod__(self, value, /)
- Return self%value.
- __ne__(self, value, /)
- Return self!=value.
- __neg__(self, /)
- -self
- __or__(self, value, /)
- Return self|value.
- __pos__(self, /)
- +self
- __radd__(self, value, /)
- Return value+self.
- __rand__(self, value, /)
- Return value&self.
- __rdivmod__(self, value, /)
- Return divmod(value, self).
- __reduce__(...)
- a.__reduce__()
For pickling.
- __reduce_ex__(...)
- Helper for pickle.
- __repr__(self, /)
- Return repr(self).
- __rfloordiv__(self, value, /)
- Return value//self.
- __rlshift__(self, value, /)
- Return value<<self.
- __rmatmul__(self, value, /)
- Return value@self.
- __rmod__(self, value, /)
- Return value%self.
- __ror__(self, value, /)
- Return value|self.
- __rrshift__(self, value, /)
- Return value>>self.
- __rshift__(self, value, /)
- Return self>>value.
- __rsub__(self, value, /)
- Return value-self.
- __rtruediv__(self, value, /)
- Return value/self.
- __rxor__(self, value, /)
- Return value^self.
- __setitem__(self, key, value, /)
- Set self[key] to value.
- __setstate__(...)
- a.__setstate__(state, /)
For unpickling.
The `state` argument must be a sequence that contains the following
elements:
Parameters
----------
version : int
optional pickle version. If omitted defaults to 0.
shape : tuple
dtype : data-type
isFortran : bool
rawdata : string or list
a binary string with the data (or a list if 'a' is an object array)
- __sizeof__(...)
- Size of object in memory, in bytes.
- __str__(self, /)
- Return str(self).
- __sub__(self, value, /)
- Return self-value.
- __truediv__(self, value, /)
- Return self/value.
- __xor__(self, value, /)
- Return self^value.
- argpartition(...)
- a.argpartition(kth, axis=-1, kind='introselect', order=None)
Returns the indices that would partition this array.
Refer to `numpy.argpartition` for full documentation.
.. versionadded:: 1.8.0
See Also
--------
numpy.argpartition : equivalent function
- argsort(...)
- a.argsort(axis=-1, kind=None, order=None)
Returns the indices that would sort this array.
Refer to `numpy.argsort` for full documentation.
See Also
--------
numpy.argsort : equivalent function
- astype(...)
- a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
Copy of the array, cast to a specified type.
Parameters
----------
dtype : str or dtype
Typecode or data-type to which the array is cast.
order : {'C', 'F', 'A', 'K'}, optional
Controls the memory layout order of the result.
'C' means C order, 'F' means Fortran order, 'A'
means 'F' order if all the arrays are Fortran contiguous,
'C' order otherwise, and 'K' means as close to the
order the array elements appear in memory as possible.
Default is 'K'.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur. Defaults to 'unsafe'
for backwards compatibility.
* 'no' means the data types should not be cast at all.
* 'equiv' means only byte-order changes are allowed.
* 'safe' means only casts which can preserve values are allowed.
* 'same_kind' means only safe casts or casts within a kind,
like float64 to float32, are allowed.
* 'unsafe' means any data conversions may be done.
subok : bool, optional
If True, then sub-classes will be passed-through (default), otherwise
the returned array will be forced to be a base-class array.
copy : bool, optional
By default, astype always returns a newly allocated array. If this
is set to false, and the `dtype`, `order`, and `subok`
requirements are satisfied, the input array is returned instead
of a copy.
Returns
-------
arr_t : ndarray
Unless `copy` is False and the other conditions for returning the input
array are satisfied (see description for `copy` input parameter), `arr_t`
is a new array of the same shape as the input array, with dtype, order
given by `dtype`, `order`.
Notes
-----
.. versionchanged:: 1.17.0
Casting between a simple data type and a structured one is possible only
for "unsafe" casting. Casting to multiple fields is allowed, but
casting from multiple fields is not.
.. versionchanged:: 1.9.0
Casting from numeric to string types in 'safe' casting mode requires
that the string dtype length is long enough to store the max
integer/float value converted.
Raises
------
ComplexWarning
When casting from complex to float or int. To avoid this,
one should use ``a.real.astype(t)``.
Examples
--------
>>> x = np.array([1, 2, 2.5])
>>> x
array([1. , 2. , 2.5])
>>> x.astype(int)
array([1, 2, 2])
- byteswap(...)
- a.byteswap(inplace=False)
Swap the bytes of the array elements
Toggle between low-endian and big-endian data representation by
returning a byteswapped array, optionally swapped in-place.
Arrays of byte-strings are not swapped. The real and imaginary
parts of a complex number are swapped individually.
Parameters
----------
inplace : bool, optional
If ``True``, swap bytes in-place, default is ``False``.
Returns
-------
out : ndarray
The byteswapped array. If `inplace` is ``True``, this is
a view to self.
Examples
--------
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> list(map(hex, A))
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([ 256, 1, 13090], dtype=int16)
>>> list(map(hex, A))
['0x100', '0x1', '0x3322']
Arrays of byte-strings are not swapped
>>> A = np.array([b'ceg', b'fac'])
>>> A.byteswap()
array([b'ceg', b'fac'], dtype='|S3')
``A.newbyteorder().byteswap()`` produces an array with the same values
but different representation in memory
>>> A = np.array([1, 2, 3])
>>> A.view(np.uint8)
array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
0, 0], dtype=uint8)
>>> A.newbyteorder().byteswap(inplace=True)
array([1, 2, 3])
>>> A.view(np.uint8)
array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
0, 3], dtype=uint8)
- choose(...)
- a.choose(choices, out=None, mode='raise')
Use an index array to construct a new array from a set of choices.
Refer to `numpy.choose` for full documentation.
See Also
--------
numpy.choose : equivalent function
- clip(...)
- a.clip(min=None, max=None, out=None, **kwargs)
Return an array whose values are limited to ``[min, max]``.
One of max or min must be given.
Refer to `numpy.clip` for full documentation.
See Also
--------
numpy.clip : equivalent function
- compress(...)
- a.compress(condition, axis=None, out=None)
Return selected slices of this array along given axis.
Refer to `numpy.compress` for full documentation.
See Also
--------
numpy.compress : equivalent function
- conj(...)
- a.conj()
Complex-conjugate all elements.
Refer to `numpy.conjugate` for full documentation.
See Also
--------
numpy.conjugate : equivalent function
- conjugate(...)
- a.conjugate()
Return the complex conjugate, element-wise.
Refer to `numpy.conjugate` for full documentation.
See Also
--------
numpy.conjugate : equivalent function
- copy(...)
- a.copy(order='C')
Return a copy of the array.
Parameters
----------
order : {'C', 'F', 'A', 'K'}, optional
Controls the memory layout of the copy. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
'C' otherwise. 'K' means match the layout of `a` as closely
as possible. (Note that this function and :func:`numpy.copy` are very
similar, but have different default values for their order=
arguments.)
See also
--------
numpy.copy
numpy.copyto
Examples
--------
>>> x = np.array([[1,2,3],[4,5,6]], order='F')
>>> y = x.copy()
>>> x.fill(0)
>>> x
array([[0, 0, 0],
[0, 0, 0]])
>>> y
array([[1, 2, 3],
[4, 5, 6]])
>>> y.flags['C_CONTIGUOUS']
True
- cumprod(...)
- a.cumprod(axis=None, dtype=None, out=None)
Return the cumulative product of the elements along the given axis.
Refer to `numpy.cumprod` for full documentation.
See Also
--------
numpy.cumprod : equivalent function
- cumsum(...)
- a.cumsum(axis=None, dtype=None, out=None)
Return the cumulative sum of the elements along the given axis.
Refer to `numpy.cumsum` for full documentation.
See Also
--------
numpy.cumsum : equivalent function
- diagonal(...)
- a.diagonal(offset=0, axis1=0, axis2=1)
Return specified diagonals. In NumPy 1.9 the returned array is a
read-only view instead of a copy as in previous NumPy versions. In
a future version the read-only restriction will be removed.
Refer to :func:`numpy.diagonal` for full documentation.
See Also
--------
numpy.diagonal : equivalent function
- dot(...)
- a.dot(b, out=None)
Dot product of two arrays.
Refer to `numpy.dot` for full documentation.
See Also
--------
numpy.dot : equivalent function
Examples
--------
>>> a = np.eye(2)
>>> b = np.ones((2, 2)) * 2
>>> a.dot(b)
array([[2., 2.],
[2., 2.]])
This array method can be conveniently chained:
>>> a.dot(b).dot(b)
array([[8., 8.],
[8., 8.]])
- dump(...)
- a.dump(file)
Dump a pickle of the array to the specified file.
The array can be read back with pickle.load or numpy.load.
Parameters
----------
file : str or Path
A string naming the dump file.
.. versionchanged:: 1.17.0
`pathlib.Path` objects are now accepted.
- dumps(...)
- a.dumps()
Returns the pickle of the array as a string.
pickle.loads or numpy.loads will convert the string back to an array.
Parameters
----------
None
- fill(...)
- a.fill(value)
Fill the array with a scalar value.
Parameters
----------
value : scalar
All elements of `a` will be assigned this value.
Examples
--------
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1., 1.])
- getfield(...)
- a.getfield(dtype, offset=0)
Returns a field of the given array as a certain type.
A field is a view of the array data with a given data-type. The values in
the view are determined by the given type and the offset into the current
array in bytes. The offset needs to be such that the view dtype fits in the
array dtype; for example an array of dtype complex128 has 16-byte elements.
If taking a view with a 32-bit integer (4 bytes), the offset needs to be
between 0 and 12 bytes.
Parameters
----------
dtype : str or dtype
The data type of the view. The dtype size of the view can not be larger
than that of the array itself.
offset : int
Number of bytes to skip before beginning the element view.
Examples
--------
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[1.+1.j, 0.+0.j],
[0.+0.j, 2.+4.j]])
>>> x.getfield(np.float64)
array([[1., 0.],
[0., 2.]])
By choosing an offset of 8 bytes we can select the complex part of the
array for our view:
>>> x.getfield(np.float64, offset=8)
array([[1., 0.],
[0., 4.]])
- item(...)
- a.item(*args)
Copy an element of an array to a standard Python scalar and return it.
Parameters
----------
\*args : Arguments (variable number and type)
* none: in this case, the method only works for arrays
with one element (`a.size == 1`), which element is
copied into a standard Python scalar object and returned.
* int_type: this argument is interpreted as a flat index into
the array, specifying which element to copy and return.
* tuple of int_types: functions as does a single int_type argument,
except that the argument is interpreted as an nd-index into the
array.
Returns
-------
z : Standard Python scalar object
A copy of the specified element of the array as a suitable
Python scalar
Notes
-----
When the data type of `a` is longdouble or clongdouble, item() returns
a scalar array object because there is no available Python scalar that
would not lose information. Void arrays return a buffer object for item(),
unless fields are defined, in which case a tuple is returned.
`item` is very similar to a[args], except, instead of an array scalar,
a standard Python scalar is returned. This can be useful for speeding up
access to elements of the array and doing arithmetic on elements of the
array using Python's optimized math.
Examples
--------
>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
[1, 3, 6],
[1, 0, 1]])
>>> x.item(3)
1
>>> x.item(7)
0
>>> x.item((0, 1))
2
>>> x.item((2, 2))
1
- itemset(...)
- a.itemset(*args)
Insert scalar into an array (scalar is cast to array's dtype, if possible)
There must be at least 1 argument, and define the last argument
as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster
than ``a[args] = item``. The item should be a scalar value and `args`
must select a single item in the array `a`.
Parameters
----------
\*args : Arguments
If one argument: a scalar, only used in case `a` is of size 1.
If two arguments: the last argument is the value to be set
and must be a scalar, the first argument specifies a single array
element location. It is either an int or a tuple.
Notes
-----
Compared to indexing syntax, `itemset` provides some speed increase
for placing a scalar into a particular location in an `ndarray`,
if you must do this. However, generally this is discouraged:
among other problems, it complicates the appearance of the code.
Also, when using `itemset` (and `item`) inside a loop, be sure
to assign the methods to a local variable to avoid the attribute
look-up at each loop iteration.
Examples
--------
>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
[1, 3, 6],
[1, 0, 1]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[2, 2, 6],
[1, 0, 6],
[1, 0, 9]])
- newbyteorder(...)
- arr.newbyteorder(new_order='S')
Return the array with the same data viewed with a different byte order.
Equivalent to::
arr.view(arr.dtype.newbytorder(new_order))
Changes are also made in all fields and sub-arrays of the array data
type.
Parameters
----------
new_order : string, optional
Byte order to force; a value from the byte order specifications
below. `new_order` codes can be any of:
* 'S' - swap dtype from current to opposite endian
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* {'|', 'I'} - ignore (no change to byte order)
The default value ('S') results in swapping the current
byte order. The code does a case-insensitive check on the first
letter of `new_order` for the alternatives above. For example,
any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
Returns
-------
new_arr : array
New array object with the dtype reflecting given change to the
byte order.
- nonzero(...)
- a.nonzero()
Return the indices of the elements that are non-zero.
Refer to `numpy.nonzero` for full documentation.
See Also
--------
numpy.nonzero : equivalent function
- partition(...)
- a.partition(kth, axis=-1, kind='introselect', order=None)
Rearranges the elements in the array in such a way that the value of the
element in kth position is in the position it would be in a sorted array.
All elements smaller than the kth element are moved before this element and
all equal or greater are moved behind it. The ordering of the elements in
the two partitions is undefined.
.. versionadded:: 1.8.0
Parameters
----------
kth : int or sequence of ints
Element index to partition by. The kth element value will be in its
final sorted position and all smaller elements will be moved before it
and all equal or greater elements behind it.
The order of all elements in the partitions is undefined.
If provided with a sequence of kth it will partition all elements
indexed by kth of them into their sorted position at once.
axis : int, optional
Axis along which to sort. Default is -1, which means sort along the
last axis.
kind : {'introselect'}, optional
Selection algorithm. Default is 'introselect'.
order : str or list of str, optional
When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc. A single field can
be specified as a string, and not all fields need to be specified,
but unspecified fields will still be used, in the order in which
they come up in the dtype, to break ties.
See Also
--------
numpy.partition : Return a parititioned copy of an array.
argpartition : Indirect partition.
sort : Full sort.
Notes
-----
See ``np.partition`` for notes on the different algorithms.
Examples
--------
>>> a = np.array([3, 4, 2, 1])
>>> a.partition(3)
>>> a
array([2, 1, 3, 4])
>>> a.partition((1, 3))
>>> a
array([1, 2, 3, 4])
- put(...)
- a.put(indices, values, mode='raise')
Set ``a.flat[n] = values[n]`` for all `n` in indices.
Refer to `numpy.put` for full documentation.
See Also
--------
numpy.put : equivalent function
- repeat(...)
- a.repeat(repeats, axis=None)
Repeat elements of an array.
Refer to `numpy.repeat` for full documentation.
See Also
--------
numpy.repeat : equivalent function
- reshape(...)
- a.reshape(shape, order='C')
Returns an array containing the same data with a new shape.
Refer to `numpy.reshape` for full documentation.
See Also
--------
numpy.reshape : equivalent function
Notes
-----
Unlike the free function `numpy.reshape`, this method on `ndarray` allows
the elements of the shape parameter to be passed in as separate arguments.
For example, ``a.reshape(10, 11)`` is equivalent to
``a.reshape((10, 11))``.
- resize(...)
- a.resize(new_shape, refcheck=True)
Change shape and size of array in-place.
Parameters
----------
new_shape : tuple of ints, or `n` ints
Shape of resized array.
refcheck : bool, optional
If False, reference count will not be checked. Default is True.
Returns
-------
None
Raises
------
ValueError
If `a` does not own its own data or references or views to it exist,
and the data memory must be changed.
PyPy only: will always raise if the data memory must be changed, since
there is no reliable way to determine if references or views to it
exist.
SystemError
If the `order` keyword argument is specified. This behaviour is a
bug in NumPy.
See Also
--------
resize : Return a new array with the specified shape.
Notes
-----
This reallocates space for the data area if necessary.
Only contiguous arrays (data elements consecutive in memory) can be
resized.
The purpose of the reference count check is to make sure you
do not use this array as a buffer for another Python object and then
reallocate the memory. However, reference counts can increase in
other ways so if you are sure that you have not shared the memory
for this array with another Python object, then you may safely set
`refcheck` to False.
Examples
--------
Shrinking an array: array is flattened (in the order that the data are
stored in memory), resized, and reshaped:
>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
[1]])
>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
[2]])
Enlarging an array: as above, but missing entries are filled with zeros:
>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
[3, 0, 0]])
Referencing an array prevents resizing...
>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that references or is referenced ...
Unless `refcheck` is False:
>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])
- round(...)
- a.round(decimals=0, out=None)
Return `a` with each element rounded to the given number of decimals.
Refer to `numpy.around` for full documentation.
See Also
--------
numpy.around : equivalent function
- searchsorted(...)
- a.searchsorted(v, side='left', sorter=None)
Find indices where elements of v should be inserted in a to maintain order.
For full documentation, see `numpy.searchsorted`
See Also
--------
numpy.searchsorted : equivalent function
- setfield(...)
- a.setfield(val, dtype, offset=0)
Put a value into a specified place in a field defined by a data-type.
Place `val` into `a`'s field defined by `dtype` and beginning `offset`
bytes into the field.
Parameters
----------
val : object
Value to be placed in field.
dtype : dtype object
Data-type of the field in which to place `val`.
offset : int, optional
The number of bytes into the field at which to place `val`.
Returns
-------
None
See Also
--------
getfield
Examples
--------
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
[3, 3, 3],
[3, 3, 3]], dtype=int32)
>>> x
array([[1.0e+000, 1.5e-323, 1.5e-323],
[1.5e-323, 1.0e+000, 1.5e-323],
[1.5e-323, 1.5e-323, 1.0e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
- setflags(...)
- a.setflags(write=None, align=None, uic=None)
Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
respectively.
These Boolean-valued flags affect how numpy interprets the memory
area used by `a` (see Notes below). The ALIGNED flag can only
be set to True if the data is actually aligned according to the type.
The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
to True. The flag WRITEABLE can only be set to True if the array owns its
own memory, or the ultimate owner of the memory exposes a writeable buffer
interface, or is a string. (The exception for string is made so that
unpickling can be done without copying memory.)
Parameters
----------
write : bool, optional
Describes whether or not `a` can be written to.
align : bool, optional
Describes whether or not `a` is aligned properly for its type.
uic : bool, optional
Describes whether or not `a` is a copy of another "base" array.
Notes
-----
Array flags provide information about how the memory area used
for the array is to be interpreted. There are 7 Boolean flags
in use, only four of which can be changed by the user:
WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
WRITEABLE (W) the data area can be written to;
ALIGNED (A) the data and strides are aligned appropriately for the hardware
(as determined by the compiler);
UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
called, the base array will be updated with the contents of this array.
All flags can be accessed using the single (upper case) letter as well
as the full name.
Examples
--------
>>> y = np.array([[3, 1, 7],
... [2, 0, 0],
... [8, 5, 9]])
>>> y
array([[3, 1, 7],
[2, 0, 0],
[8, 5, 9]])
>>> y.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : False
ALIGNED : False
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: cannot set WRITEBACKIFCOPY flag to True
- sort(...)
- a.sort(axis=-1, kind=None, order=None)
Sort an array in-place. Refer to `numpy.sort` for full documentation.
Parameters
----------
axis : int, optional
Axis along which to sort. Default is -1, which means sort along the
last axis.
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
and 'mergesort' use timsort under the covers and, in general, the
actual implementation will vary with datatype. The 'mergesort' option
is retained for backwards compatibility.
.. versionchanged:: 1.15.0.
The 'stable' option was added.
order : str or list of str, optional
When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc. A single field can
be specified as a string, and not all fields need be specified,
but unspecified fields will still be used, in the order in which
they come up in the dtype, to break ties.
See Also
--------
numpy.sort : Return a sorted copy of an array.
numpy.argsort : Indirect sort.
numpy.lexsort : Indirect stable sort on multiple keys.
numpy.searchsorted : Find elements in sorted array.
numpy.partition: Partial sort.
Notes
-----
See `numpy.sort` for notes on the different sorting algorithms.
Examples
--------
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
[1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
[1, 4]])
Use the `order` keyword to specify a field to use when sorting a
structured array:
>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([(b'c', 1), (b'a', 2)],
dtype=[('x', 'S1'), ('y', '<i8')])
- swapaxes(...)
- a.swapaxes(axis1, axis2)
Return a view of the array with `axis1` and `axis2` interchanged.
Refer to `numpy.swapaxes` for full documentation.
See Also
--------
numpy.swapaxes : equivalent function
- take(...)
- a.take(indices, axis=None, out=None, mode='raise')
Return an array formed from the elements of `a` at the given indices.
Refer to `numpy.take` for full documentation.
See Also
--------
numpy.take : equivalent function
- tobytes(...)
- a.tobytes(order='C')
Construct Python bytes containing the raw data bytes in the array.
Constructs Python bytes showing a copy of the raw contents of
data memory. The bytes object can be produced in either 'C' or 'Fortran',
or 'Any' order (the default is 'C'-order). 'Any' order means C-order
unless the F_CONTIGUOUS flag in the array is set, in which case it
means 'Fortran' order.
.. versionadded:: 1.9.0
Parameters
----------
order : {'C', 'F', None}, optional
Order of the data for multidimensional arrays:
C, Fortran, or the same as for the original array.
Returns
-------
s : bytes
Python bytes exhibiting a copy of `a`'s raw data.
Examples
--------
>>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
>>> x.tobytes()
b'\x00\x00\x01\x00\x02\x00\x03\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x02\x00\x01\x00\x03\x00'
- tofile(...)
- a.tofile(fid, sep="", format="%s")
Write array to a file as text or binary (default).
Data is always written in 'C' order, independent of the order of `a`.
The data produced by this method can be recovered using the function
fromfile().
Parameters
----------
fid : file or str or Path
An open file object, or a string containing a filename.
.. versionchanged:: 1.17.0
`pathlib.Path` objects are now accepted.
sep : str
Separator between array items for text output.
If "" (empty), a binary file is written, equivalent to
``file.write(a.tobytes())``.
format : str
Format string for text file output.
Each entry in the array is formatted to text by first converting
it to the closest Python type, and then using "format" % item.
Notes
-----
This is a convenience function for quick storage of array data.
Information on endianness and precision is lost, so this method is not a
good choice for files intended to archive data or transport data between
machines with different endianness. Some of these problems can be overcome
by outputting the data as text files, at the expense of speed and file
size.
When fid is a file object, array contents are directly written to the
file, bypassing the file object's ``write`` method. As a result, tofile
cannot be used with files objects supporting compression (e.g., GzipFile)
or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
- tostring(...)
- a.tostring(order='C')
Construct Python bytes containing the raw data bytes in the array.
Constructs Python bytes showing a copy of the raw contents of
data memory. The bytes object can be produced in either 'C' or 'Fortran',
or 'Any' order (the default is 'C'-order). 'Any' order means C-order
unless the F_CONTIGUOUS flag in the array is set, in which case it
means 'Fortran' order.
This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
Parameters
----------
order : {'C', 'F', None}, optional
Order of the data for multidimensional arrays:
C, Fortran, or the same as for the original array.
Returns
-------
s : bytes
Python bytes exhibiting a copy of `a`'s raw data.
Examples
--------
>>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
>>> x.tobytes()
b'\x00\x00\x01\x00\x02\x00\x03\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x02\x00\x01\x00\x03\x00'
- trace(...)
- a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
Return the sum along diagonals of the array.
Refer to `numpy.trace` for full documentation.
See Also
--------
numpy.trace : equivalent function
- transpose(...)
- a.transpose(*axes)
Returns a view of the array with axes transposed.
For a 1-D array this has no effect, as a transposed vector is simply the
same vector. To convert a 1-D array into a 2D column vector, an additional
dimension must be added. `np.atleast2d(a).T` achieves this, as does
`a[:, np.newaxis]`.
For a 2-D array, this is a standard matrix transpose.
For an n-D array, if axes are given, their order indicates how the
axes are permuted (see Examples). If axes are not provided and
``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
Parameters
----------
axes : None, tuple of ints, or `n` ints
* None or no argument: reverses the order of the axes.
* tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
`i`-th axis becomes `a.transpose()`'s `j`-th axis.
* `n` ints: same as an n-tuple of the same ints (this form is
intended simply as a "convenience" alternative to the tuple form)
Returns
-------
out : ndarray
View of `a`, with axes suitably permuted.
See Also
--------
ndarray.T : Array property returning the array transposed.
ndarray.reshape : Give a new shape to an array without changing its data.
Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
[3, 4]])
>>> a.transpose()
array([[1, 3],
[2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
[2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
[2, 4]])
- view(...)
- a.view(dtype=None, type=None)
New view of array with the same data.
Parameters
----------
dtype : data-type or ndarray sub-class, optional
Data-type descriptor of the returned view, e.g., float32 or int16. The
default, None, results in the view having the same data-type as `a`.
This argument can also be specified as an ndarray sub-class, which
then specifies the type of the returned object (this is equivalent to
setting the ``type`` parameter).
type : Python type, optional
Type of the returned view, e.g., ndarray or matrix. Again, the
default None results in type preservation.
Notes
-----
``a.view()`` is used two different ways:
``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
of the array's memory with a different data-type. This can cause a
reinterpretation of the bytes of memory.
``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
returns an instance of `ndarray_subclass` that looks at the same array
(same shape, dtype, etc.) This does not cause a reinterpretation of the
memory.
For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
bytes per entry than the previous dtype (for example, converting a
regular array to a structured array), then the behavior of the view
cannot be predicted just from the superficial appearance of ``a`` (shown
by ``print(a)``). It also depends on exactly how ``a`` is stored in
memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
defined as a slice or transpose, etc., the view may give different
results.
Examples
--------
>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
Viewing array data using a different type and dtype:
>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> y
matrix([[513]], dtype=int16)
>>> print(type(y))
<class 'numpy.matrix'>
Creating a view on a structured array so it can be used in calculations
>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
[3, 4]], dtype=int8)
>>> xv.mean(0)
array([2., 3.])
Making changes to the view changes the underlying array
>>> xv[0,1] = 20
>>> x
array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])
Using a view to convert an array to a recarray:
>>> z = x.view(np.recarray)
>>> z.a
array([1, 3], dtype=int8)
Views share data:
>>> x[0] = (9, 10)
>>> z[0]
(9, 10)
Views that change the dtype size (bytes per entry) should normally be
avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
>>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
>>> y = x[:, 0:2]
>>> y
array([[1, 2],
[4, 5]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
...
ValueError: To change to a dtype of a different size, the array must be C-contiguous
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 2)],
[(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
Data descriptors inherited from ndarray:
- __array_interface__
- Array protocol: Python side.
- __array_struct__
- Array protocol: C-struct side.
- base
- Base object if memory is from some other object.
Examples
--------
The base of an array that owns its memory is None:
>>> x = np.array([1,2,3,4])
>>> x.base is None
True
Slicing creates a view, whose memory is shared with x:
>>> y = x[2:]
>>> y.base is x
True
- ctypes
- An object to simplify the interaction of the array with the ctypes
module.
This attribute creates an object that makes it easier to use arrays
when calling shared libraries with the ctypes module. The returned
object has, among others, data, shape, and strides attributes (see
Notes below) which themselves return ctypes objects that can be used
as arguments to a shared library.
Parameters
----------
None
Returns
-------
c : Python object
Possessing attributes data, shape, strides, etc.
See Also
--------
numpy.ctypeslib
Notes
-----
Below are the public attributes of this object which were documented
in "Guide to NumPy" (we have omitted undocumented public attributes,
as well as documented private attributes):
.. autoattribute:: numpy.core._internal._ctypes.data
:noindex:
.. autoattribute:: numpy.core._internal._ctypes.shape
:noindex:
.. autoattribute:: numpy.core._internal._ctypes.strides
:noindex:
.. automethod:: numpy.core._internal._ctypes.data_as
:noindex:
.. automethod:: numpy.core._internal._ctypes.shape_as
:noindex:
.. automethod:: numpy.core._internal._ctypes.strides_as
:noindex:
If the ctypes module is not available, then the ctypes attribute
of array objects still returns something useful, but ctypes objects
are not returned and errors may be raised instead. In particular,
the object will still have the ``as_parameter`` attribute which will
return an integer equal to the data attribute.
Examples
--------
>>> import ctypes
>>> x
array([[0, 1],
[2, 3]])
>>> x.ctypes.data
30439712
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
<ctypes.LP_c_long object at 0x01F01300>
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
c_long(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
c_longlong(4294967296L)
>>> x.ctypes.shape
<numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
>>> x.ctypes.shape_as(ctypes.c_long)
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides_as(ctypes.c_longlong)
<numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
- data
- Python buffer object pointing to the start of the array's data.
- dtype
- Data-type of the array's elements.
Parameters
----------
None
Returns
-------
d : numpy dtype object
See Also
--------
numpy.dtype
Examples
--------
>>> x
array([[0, 1],
[2, 3]])
>>> x.dtype
dtype('int32')
>>> type(x.dtype)
<type 'numpy.dtype'>
- flags
- Information about the memory layout of the array.
Attributes
----------
C_CONTIGUOUS (C)
The data is in a single, C-style contiguous segment.
F_CONTIGUOUS (F)
The data is in a single, Fortran-style contiguous segment.
OWNDATA (O)
The array owns the memory it uses or borrows it from another object.
WRITEABLE (W)
The data area can be written to. Setting this to False locks
the data, making it read-only. A view (slice, etc.) inherits WRITEABLE
from its base array at creation time, but a view of a writeable
array may be subsequently locked while the base array remains writeable.
(The opposite is not true, in that a view of a locked array may not
be made writeable. However, currently, locking a base object does not
lock any views that already reference it, so under that circumstance it
is possible to alter the contents of a locked array via a previously
created writeable view onto it.) Attempting to change a non-writeable
array raises a RuntimeError exception.
ALIGNED (A)
The data and all elements are aligned appropriately for the hardware.
WRITEBACKIFCOPY (X)
This array is a copy of some other array. The C-API function
PyArray_ResolveWritebackIfCopy must be called before deallocating
to the base array will be updated with the contents of this array.
UPDATEIFCOPY (U)
(Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
When this array is
deallocated, the base array will be updated with the contents of
this array.
FNC
F_CONTIGUOUS and not C_CONTIGUOUS.
FORC
F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
BEHAVED (B)
ALIGNED and WRITEABLE.
CARRAY (CA)
BEHAVED and C_CONTIGUOUS.
FARRAY (FA)
BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
Notes
-----
The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
names are only supported in dictionary access.
Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
changed by the user, via direct assignment to the attribute or dictionary
entry, or by calling `ndarray.setflags`.
The array flags cannot be set arbitrarily:
- UPDATEIFCOPY can only be set ``False``.
- WRITEBACKIFCOPY can only be set ``False``.
- ALIGNED can only be set ``True`` if the data is truly aligned.
- WRITEABLE can only be set ``True`` if the array owns its own memory
or the ultimate owner of the memory exposes a writeable buffer
interface or is a string.
Arrays can be both C-style and Fortran-style contiguous simultaneously.
This is clear for 1-dimensional arrays, but can also be true for higher
dimensional arrays.
Even for contiguous arrays a stride for a given dimension
``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
or the array has no elements.
It does *not* generally hold that ``self.strides[-1] == self.itemsize``
for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
Fortran-style contiguous arrays is true.
- flat
- A 1-D iterator over the array.
This is a `numpy.flatiter` instance, which acts similarly to, but is not
a subclass of, Python's built-in iterator object.
See Also
--------
flatten : Return a copy of the array collapsed into one dimension.
flatiter
Examples
--------
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
[4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
[2, 5],
[3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<class 'numpy.flatiter'>
An assignment example:
>>> x.flat = 3; x
array([[3, 3, 3],
[3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
[3, 1, 3]])
- imag
- The imaginary part of the array.
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0. , 0.70710678])
>>> x.imag.dtype
dtype('float64')
- itemsize
- Length of one array element in bytes.
Examples
--------
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16
- nbytes
- Total bytes consumed by the elements of the array.
Notes
-----
Does not include memory consumed by non-element attributes of the
array object.
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480
- ndim
- Number of array dimensions.
Examples
--------
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3
- real
- The real part of the array.
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1. , 0.70710678])
>>> x.real.dtype
dtype('float64')
See Also
--------
numpy.real : equivalent function
- shape
- Tuple of array dimensions.
The shape property is usually used to get the current shape of an array,
but may also be used to reshape the array in-place by assigning a tuple of
array dimensions to it. As with `numpy.reshape`, one of the new shape
dimensions can be -1, in which case its value is inferred from the size of
the array and the remaining dimensions. Reshaping an array in-place will
fail if a copy is required.
Examples
--------
>>> x = np.array([1, 2, 3, 4])
>>> x.shape
(4,)
>>> y = np.zeros((2, 3, 4))
>>> y.shape
(2, 3, 4)
>>> y.shape = (3, 8)
>>> y
array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.]])
>>> y.shape = (3, 6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
>>> np.zeros((4,2))[::2].shape = (-1,)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: incompatible shape for a non-contiguous array
See Also
--------
numpy.reshape : similar function
ndarray.reshape : similar method
- size
- Number of elements in the array.
Equal to ``np.prod(a.shape)``, i.e., the product of the array's
dimensions.
Notes
-----
`a.size` returns a standard arbitrary precision Python integer. This
may not be the case with other methods of obtaining the same value
(like the suggested ``np.prod(a.shape)``, which returns an instance
of ``np.int_``), and may be relevant if the value is used further in
calculations that may overflow a fixed size integer type.
Examples
--------
>>> x = np.zeros((3, 5, 2), dtype=np.complex128)
>>> x.size
30
>>> np.prod(x.shape)
30
- strides
- Tuple of bytes to step in each dimension when traversing an array.
The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
is::
offset = sum(np.array(i) * a.strides)
A more detailed explanation of strides can be found in the
"ndarray.rst" file in the NumPy reference guide.
Notes
-----
Imagine an array of 32-bit integers (each 4 bytes)::
x = np.array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]], dtype=np.int32)
This array is stored in memory as 40 bytes, one after the other
(known as a contiguous block of memory). The strides of an array tell
us how many bytes we have to skip in memory to move to the next position
along a certain axis. For example, we have to skip 4 bytes (1 value) to
move to the next column, but 20 bytes (5 values) to get to the same
position in the next row. As such, the strides for the array `x` will be
``(20, 4)``.
See Also
--------
numpy.lib.stride_tricks.as_strided
Examples
--------
>>> y = np.reshape(np.arange(2*3*4), (2,3,4))
>>> y
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
>>> y.strides
(48, 16, 4)
>>> y[1,1,1]
17
>>> offset=sum(y.strides * np.array((1,1,1)))
>>> offset/y.itemsize
17
>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813
Data and other attributes inherited from ndarray:
- __hash__ = None
|


This is my main guitar. It holds a special place in my heart, probably because it was my first nice guitar. Although it looks banged up and worn, it plays amazingly! I acquired it around 3 years ago and it was my first Ibanez Prestige (one of my favorite lines of guitars).
Here we have an Ibanez S5521 Prestige. This guitar was crafted in Japan, much like the previous guitar. However, it is much newer. This guitar was manufactured in 2015 and I purchased it new for around $1500. This thing is absolutely killer, however, I do not use it nearly as much as my RGT2020.
This is a custom shop Strandberg! It was made in Sweden and is a Made2Measure model. Basically, it is custom specs! At the time this was made, it cost around $5000, as crazy as that sounds. I actually bought this guitar used and acquired it for around $3000, which is still steep. This is a 7 string as well.
This was my first Strandberg. It is a Boden 7 made by the Washburn factory in the USA. It is an amazing guitar and one of the best 7 strings I have ever picked up! The top is figured claro walnut which looks and sounds great. The neck is an endurneck.


Voting Ends {{formatTime expiry "fromnow"}}
{{#unless executed}}
{{#if isWon}}
Proposal Won
{{/if}}
{{/unless}}
{{#if executed}}
Proposal Executed
{{/if}}
{{#unless isExecutable}}
{{#if isVotable}}
Proposal Active
{{/if}}
{{/unless}}
This proposal has {{numVotes}} voters
-
{{numWeightFor}} ({{numFor}}) for
-
{{numWeightAgainst}} ({{numAgainst}}) against
-
-
of {{numVotes}} members
{{#if isExecutable}}
{{#unless executed}}
-
{{/unless}}
{{/if}}
{{#unless isExecutable}}
{{#if isVotable}}
-
-
-
{{/if}}
{{/unless}}
{{#with TemplateVar.get 'state'}}
{{#if isMining}}
Your decision is being processed... This may take a minute.
{{/if}}
{{#if isError}}
There was an error processing your decision.
The error was: {{error}}
{{/if}}
{{#if isVoted}}
Your vote has successfully been processed!
{{/if}}
{{#if isDelegated}}
Your delegation has successfully been processed!
{{/if}}
{{#if isExecuted}}
This proposal has successfully been executed!
{{/if}}
{{/with}}
Created
{{formatTime created "fromnow"}}
{{refresh}}


The Last Dimension
Home
Sci-Fi Radio Opera
eLibrary
Blog
Shopping List
Add items by the click of a button. Remove an item by clicking it.
add_shopping_cart


LibraryFunctionAddress()
语法
Result = LibraryFunctionAddress()概要
Returns the address of the function in the library currently being examined with the ExamineLibraryFunctions() and NextLibraryFunction() functions.
参数
无.
返回值
Returns the address of the current function in memory. This is useful as parameter for the functions CallFunctionFast() or CallCFunctionFast().
备注
The function can be called by its address using prototypes. The functions CallFunctionFast() and CallCFunctionFast() can also be used for that, but prototypes are the recommended method as they are more flexible.
参阅
ExamineLibraryFunctions(), NextLibraryFunction(), LibraryFunctionName(), CallFunctionFast(), CallCFunctionFast()
已支持操作系统
Windows, Linux


US hails $110m rice export agreement with South Korea
by Agency ReportSouth Korea has agreed to buy more than $100 million in annual US rice exports, US officials said Tuesday.
Under the agreement, South Korea will provide access for 132,304 tons of American-produced rice a year at an annual value of about $110 million, the US Trade Representative’s office said in a statement.
“Exports are critical for the economic health of the US rice industry, with half our crop being exported every year,” US Agriculture Secretary Sonny Perdue said in the statement.
Following negotiations, Seoul has adopted tariff-rate import quotas for about 400,000 tons of rice from the United States, Australia, China and Thailand.
According to the US Trade Representative’s office, South Korea has allotted about a third of this to American growers, the highest volume of US access ever.
Under the World Trade Organization, South Korea had enjoyed special treatment for rice market access until this expired in 2014, when negotiations started.
The new agreement is to take effect in January.
(AFP)


Vert.x Gradle Template
Starter Template project for creating a Vert.x module with a Gradle build.
Clone this and adapt it to easily develop Vert.x modules using Gradle as your build tool.
By default this module contains a com.mycompany.myproject.HelloWorldVerticle example application implemented in all stable language implementations currently supported by vert.x.
This template provides a gradle 2.2 wrapper.
Getting started
Clone this repo, replace origin
with your preferred one and run gradlew
to
test whether everything is working.
git clone git@github.com:macedigital/vertx-gradle-template.git <name of your project>
cd <name of your project>
git remote rm origin
git remote add origin <path to your repo>
./gradlew test
For further details go to http://vertx.io/gradle_dev.html.
Configure the project
You can configure many things in gradle.properties
:
- Change
modowner
,modname
andversion
to your liking as described in the modules manual. pullInDeps
determines whether all module dependencies should be packaged into the module as nested module (default: true).produceJar
Set to true if you want the build to output a jar as well as a module zip file (default: true).createFatJar
Set to true if you want to build a fat executable jar containing everything needed to run the module (default: false).
Remove or add dependencies in build.gradle
:
- Depending on your chosen programming language(s) you can safely remove lang-mods you neither
want nor need in
dependencies
. - If you plan on publishing your mod to Maven, you will want to edit
configurePom
.
You can provide default module
configuration if any in conf.json
.
Setup your IDE
You can use the idea
and eclipse
Gradle plugins to create the project files
for your IDE.
./gradlew idea
Or
./gradlew eclipse
Once the IDE files have been created you can open the project in your IDE.
See the build script
for the list of useful tasks
FAQ
- gradle command
runMod
fails to find classpath:- invoking the script
env -u VERTX_MODS ./gradlew runMod
can help if developing a single module
- invoking the script
- Running / compiling JRuby verticle fails with
org.vertx.java.core.VertxException: org.jruby.embed.EvalFailedException: (Errno::ENOENT) <some/directory>
- manually create
and try again
- manually create
- JRuby fails with
LoadError: no such file to load -- rubygems
- try setting
RUBYOPT
environment variable, e.g.export RUBYOPT=rubygems && ./gradlew runMod
[1].
- try setting
- Task 'runMod' fails with java.lang.ClassNotFoundException:
- Besides the obvious, also check if you have the
VERTX_MODS
environment variable set. If so, unset it by running gradle wrapper like so insteadenv -u VERTX_MODS ./gradlew runMod
.
- Besides the obvious, also check if you have the


A new horizon...
Posted: Thu Apr 20, 2006 9:03 pm
We've moved over to a new server with lots of bandwidth. Hopefully there won't be any issues with it--the biggest problem we had on our old one was the bots.
Unfortunately, we weren't able to keep user names or the old posts when we moved. But hey, now we have a clean slate on which to draw. Here are my recent sketches:
The Born to Rule client has a really good feel to it. It's pretty slow on older machines, though--I'll definitely have to fix this. After all, if people can't play then there's not much point in having a game. I really like the way that it is coded, however, so there are probably some optimizations I need to do that don't have to do with its coding, but more with its design. Hopefully there won't be too many problems with this.
In the light of our new design model, I'm changing the way the program works a little bit. One thing I recently came up with is called UnseenDT (or Unseen Data Template) that allows anyone to easily design and create data structures. Whoop-de-doo, data, why does that matter? Because maps are just data structures. UnseenDT is very flexible and reasonably intuitive. I think it'd be cool to release a "mapping" version of BtR without content, but with an UnseenDT reader so you guys can make some maps (by typing stuff into a file, for now) and fly around in them.
For now, however, I just have these screenshots from the client to show. Please ignore the ugly and obtrusive chat window.
<center> </center>
Unfortunately, we weren't able to keep user names or the old posts when we moved. But hey, now we have a clean slate on which to draw. Here are my recent sketches:
The Born to Rule client has a really good feel to it. It's pretty slow on older machines, though--I'll definitely have to fix this. After all, if people can't play then there's not much point in having a game. I really like the way that it is coded, however, so there are probably some optimizations I need to do that don't have to do with its coding, but more with its design. Hopefully there won't be too many problems with this.
In the light of our new design model, I'm changing the way the program works a little bit. One thing I recently came up with is called UnseenDT (or Unseen Data Template) that allows anyone to easily design and create data structures. Whoop-de-doo, data, why does that matter? Because maps are just data structures. UnseenDT is very flexible and reasonably intuitive. I think it'd be cool to release a "mapping" version of BtR without content, but with an UnseenDT reader so you guys can make some maps (by typing stuff into a file, for now) and fly around in them.
For now, however, I just have these screenshots from the client to show. Please ignore the ugly and obtrusive chat window.
<center> </center>


Full name:
Enter your first and last name.
Username:
Pick a unique name on Twitter.
Password:
6 characters or more (be tricky!).
Email:
We'll send you a confirmation.
适用浏览器：IE8、360、FireFox、Chrome、Safari、Opera、傲游、搜狗、世界之窗.


Your summer personality is: The Shade Queen.
To all the Shade Queens out there: we see you and we feel your pain. Summer isn’t your favourite season, so you’re the one sitting in full shade covered in a towel, sunnies and a massive hat while your mates lounge in the sun. You might even wear a chic driving glove to keep your driving hand from seeing the sun. (OK, you probably don’t wear a driving glove…) Shade Queens love the social aspect of summer, just not the bit where you have to sit in the sun getting all sweaty, itchy and hot and bothered.
Your sunscreen =
NIVEA
SUN Sensitive Protect SPF50.
Highly effective and non-greasy, with soothing Aloe Vera, Chamomile
and Vitamin E that won’t irritate sensitive skin.
Always read the label. Follow the directions for use. Prolonged high-risk sun exposure should be avoided. Use
in accordance with directions is required for effective sun protection.
Your summer personality is: The Ultra Sporty Sort.
If it’s summer, you are outside. We repeat. ANYTHING, OUTSIDE. Sure,
there’s a time and place for watching Netflix and sleeping in, but
glorious summer days are not it. More often than not, you’re up early
walking the dog or out with the kids, playing in your social sports
team, heading down to the beach in the late afternoon to watch the
sunset.
Your sunscreen =
NIVEA
SUN Ultra Sport Cooling Sunscreen Spray SPF50+.
High performance sunscreen with four-hour sweat and water resistance.
Always read the label. Follow the directions for use. Prolonged high-risk sun exposure should be avoided. Use
in accordance with directions is required for effective sun protection.
Your summer personality is: The Beach Creature.
If you were an animal, you’d be a lizard because you will be lying at the beach almost every single day during the summer months. Except when you have to go to work. Annoying. You’re a sun (safe) worshipper who feels most at home on a towel on the sand at a secret beach on the locals know about - crowded tourist beaches are for one-off beach visits, not seasoned beach professionals. There’s something about feeling the sand in your toes and hearing the ocean that makes you feel like your very best self. You also own way too many pairs of swimmers!
Your sunscreen =
NIVEA
SUN Ultra Beach Sunscreen Spray SPF50+.
A light, hydrating, effective formula that won’t leave your skin dry
and tight while at the beach. The pump spray bottle makes it easy to
reapply, and it's compliant with the Hawaii Reef Bill.
Always read the label. Follow the directions for use. Prolonged high-risk sun exposure should be avoided. Use
in accordance with directions is required for effective sun protection.
Your summer personality is: The Social Butterfly.
Summer to you means one thing above all else. PARTY TIME! Some people get exhausted by the endless summer party invites, but not you. You live for it. You say YES to all the after work drinks, backyard barbies, house parties, beach picnics and Sunday sessions. You get your energy from having your favourite people around you and will rarely turn down a chance to catch up. In other words, Daylight Savings is your jam. Bring on long summer days and balmy summer nights.
Your sunscreen =
NIVEA SUN UV Face
Shine Control SPF50.
The hydrating, non-greasy formula is instantly mattifying, leaving a 0% sticky feeling. It protects from UVA/UVB
as well as High Energy Visible Light. Perfect to wear under makeup.
Always read the label. Follow the directions for use. Prolonged high-risk sun exposure should be avoided. Use
in accordance with directions is required for effective sun protection.


The InstanceManager is responsible for any runtime information associated with the Zend\Di\Di DiC. This means that the information that goes into the instance manager is specific to both how the particular consuming Application’s needs and even more specifically to the environment in which the application is running.
Parameters are simply entry points for either dependencies or instance configuration values. A class consists of a set of parameters, each uniquely named. When writing your classes, you should attempt to not use the same parameter name twice in the same class when you expect that that parameters is used for either instance configuration or an object dependency. This leads to an ambiguous parameter, and is a situation best avoided.
Our movie finder example can be further used to explain these concepts:
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 | namespace MyLibrary
{
class DbAdapter
{
protected $username = null;
protected $password = null;
public function __construct($username, $password)
{
$this->username = $username;
$this->password = $password;
}
}
}
namespace MyMovieApp
{
class MovieFinder
{
protected $dbAdapter = null;
public function __construct(\MyLibrary\DbAdapter $dbAdapter)
{
$this->dbAdapter = $dbAdapter;
}
}
class MovieLister
{
protected $movieFinder = null;
public function __construct(MovieFinder $movieFinder)
{
$this->movieFinder = $movieFinder;
}
}
}
|
In the above example, the class DbAdapter has 2 parameters: username and password; MovieFinder has one parameter: dbAdapter, and MovieLister has one parameter: movieFinder. Any of these can be utilized for injection of either dependencies or scalar values during instance configuration or during call time.
When looking at the above code, since the dbAdapter parameter and the movieFinder parameter are both type-hinted with concrete types, the DiC can assume that it can fulfill these object tendencies by itself. On the other hand, username and password do not have type-hints and are, more than likely, scalar in nature. Since the DiC cannot reasonably know this information, it must be provided to the instance manager in the form of parameters. Not doing so will force $di->get(‘MyMovieApp\MovieLister’) to throw an exception.
The following ways of using parameters are available:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | // setting instance configuration into the instance manager
$di->instanceManager()->setParameters('MyLibrary\DbAdapter', array(
'username' => 'myusername',
'password' => 'mypassword'
));
// forcing a particular dependency to be used by the instance manager
$di->instanceManager()->setParameters('MyMovieApp\MovieFinder', array(
'dbAdapter' => new MyLibrary\DbAdapter('myusername', 'mypassword')
));
// passing instance parameters at call time
$movieLister = $di->get('MyMovieApp\MovieLister', array(
'username' => $config->username,
'password' => $config->password
));
// passing a specific instance at call time
$movieLister = $di->get('MyMovieApp\MovieLister', array(
'dbAdapter' => new MyLibrary\DbAdapter('myusername', 'mypassword')
));
|
In some cases, you might be using interfaces as type hints as opposed to concrete types. Lets assume the movie example was modified in the following way:
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 | namespace MyMovieApp
{
interface MovieFinderInterface
{
// methods required for this type
}
class GenericMovieFinder implements MovieFinderInterface
{
protected $dbAdapter = null;
public function __construct(\MyLibrary\DbAdapter $dbAdapter)
{
$this->dbAdapter = $dbAdapter;
}
}
class MovieLister
{
protected $movieFinder = null;
public function __construct(MovieFinderInterface $movieFinder)
{
$this->movieFinder = $movieFinder;
}
}
}
|
What you’ll notice above is that now the MovieLister type minimally expects that the dependency injected implements the MovieFinderInterface. This allows multiple implementations of this base interface to be used as a dependency, if that is what the consumer decides they want to do. As you can imagine, Zend\Di, by itself would not be able to determine what kind of concrete object to use fulfill this dependency, so this type of ‘preference’ needs to be made known to the instance manager.
To give this information to the instance manager, see the following code example:
1 2 3 | $di->instanceManager()->addTypePreference('MyMovieApp\MovieFinderInterface', 'MyMovieApp\GenericMovieFinder');
// assuming all instance config for username, password is setup
$di->get('MyMovieApp\MovieLister');
|
In some situations, you’ll find that you need to alias an instance. There are two main reasons to do this. First, it creates a simpler, alternative name to use when using the DiC, as opposed to using the full class name. Second, you might find that you need to have the same object type in two separate contexts. This means that when you alias a particular class, you can then attach a specific instance configuration to that alias; as opposed to attaching that configuration to the class name.
To demonstrate both of these points, we’ll look at a use case where we’ll have two separate DbAdapters, one will be for read-only operations, the other will be for read-write operations:
Note
Aliases can also have parameters registered at alias time
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | // assume the MovieLister example of code from the QuickStart
$im = $di->instanceManager();
// add alias for short naming
$im->addAlias('movielister', 'MyMovieApp\MovieLister');
// add aliases for specific instances
$im->addAlias('dbadapter-readonly', 'MyLibrary\DbAdapter', array(
'username' => $config->db->readAdapter->username,
'password' => $config->db->readAdapter->password,
));
$im->addAlias('dbadapter-readwrite', 'MyLibrary\DbAdapter', array(
'username' => $config->db->readWriteAdapter->username,
'password' => $config->db->readWriteAdapter->password,
));
// set a default type to use, pointing to an alias
$im->addTypePreference('MyLibrary\DbAdapter', 'dbadapter-readonly');
$movieListerRead = $di->get('MyMovieApp\MovieLister');
$movieListerReadWrite = $di->get('MyMovieApp\MovieLister', array('dbAdapter' => 'dbadapter-readwrite'));
|
The source code of this file is hosted on GitHub. Everyone can update and fix errors in this document with few clicks - no downloads needed.


It's about time you showed up!
Cubing Icons that are allowed (see license) for all projects! There should probably be more text here.
How to Use
-
Download the icons here.
Extract the files and place cubing-icons.css into your css directory.
-
Put this CSS file in the

tag of your web page:
<link rel="stylesheet" href="css/cubing-icons.css">
-
To use the icons, such as , use the following code:

-
See below for a full list of icons.
Cubing Icons List
-
cubing-icon icon-222
-
cubing-icon icon-333
-
cubing-icon icon-333bf
-
cubing-icon icon-333fm
-
cubing-icon icon-333ft
-
cubing-icon icon-333mbf
-
cubing-icon icon-333oh
-
cubing-icon icon-444
-
cubing-icon icon-444bf
-
cubing-icon icon-555
-
cubing-icon icon-555bf
-
cubing-icon icon-666
-
cubing-icon icon-777
-
cubing-icon icon-clock
-
cubing-icon icon-minx
-
cubing-icon icon-pyram
-
cubing-icon icon-skewb
-
cubing-icon icon-sq1
-
cubing-icon icon-10e3
-
cubing-icon icon-A3d1
-
cubing-icon icon-A4b
-
cubing-icon icon-A4b1
-
cubing-icon icon-A4d1
-
cubing-icon icon-A6c
-
cubing-icon icon-A6d
-
cubing-icon icon-A6e


Code Wars II
Danger Level: Black
}Matrix Amazement~
Point Value: 13
Problem Statement
Political prisoner Bobby "Byte" Bouchet has been captured in a hostile military zone and confined to a cell four feet on each side. You work for a foreign intelligence service assigned to free Bouchet. The operative needs to override the access rights of the security doors, and your task is to write the decoder.
Each door has a local security controller with a 4x4 matrix of byte control codes that are changed on a daily basis. The matrix override sequence is a "path" of values through the matrix which conforms to the following rules:
Each security door is described in the input file PROB15.IN by a series of five lines. The first line in each descriptor is an identifier, and the next four lines are each a sequence of four numbers, with each line representing a matrix row and each number in column sequence. There may be several doors in the file. For example:
DOOR NUMBER 1
12 26 7
31
101 8 61 44
18 82 13 119
83 3 47 251
Program Output
For each security door the program should print, on one line, the identifier and the command override sequence. For example:
DOOR NUMBER 1: 12 26 7 61 13 82 3 47
251


The value of this setting will be used as a multiplier for unit.
unit, unit_count, and optionally, epoch, are used by Curator to establish the moment in time point of reference with this formula:
point_of_reference = epoch - ((number of seconds in unit) * unit_count)
If epoch is unset, the current time is used. It is possible to set a point of reference in the future by using a negative value for unit_count.
This setting must be set by the user or an exception will be raised, and execution will halt.


Home
About us
Add Cottage
Book Now
You Are Looking In:
-Please Choose Your City-
Amman
Salt
Irbid
Jerash
For How Many People:
-Please Choose How many People-
1-9
10-19
20-50


---
layout: page
title: FreeRADIUS 'man' pages
subtitle: Documentation from the server
subpage: true
navorder: 200
hero: documentation
subnav:
- text: Programs
link: '/radiusd/man/#programs'
- text: Configuration Files
link: '/radiusd/man/#files'
- text: Modules
link: '/radiusd/man/#modules'
---
rlm_attr_rewrite
Section: FreeRADIUS Module (5)
Updated: 3 February 2004
Index
Return to Main Contents
NAME
rlm_attr_rewrite - FreeRADIUS Module
DESCRIPTION
The
rlm_attr_rewrite module provides functionality to rewrite
data in radius packets on the fly. This can be useful in
authorization and accounting functions.
The main configuration items to be aware of are:
- attribute
-
The name of the attribute that you want to be rewritten
- searchfor
-
String to be replaced.
- searchin
-
Where to look for the attribute. Valid values are:
packet,
reply,
proxy,
proxy_reply,
config
- replacewith
-
String to replace "searchfor".
- append
-
Set to yes or no. If set to yes then the replace string will be
appended to the original string.
- ignore_case
-
Set to yes or no. Determines whether search will be case insensitive
or case sensitive.
- new_attribute
-
Set to yes or no. If set to yes, then new attribute will be created
with values from "searchin" and "replacewith". Other options will be
ignored.
- max_matches
-
Set the max number of attributes to match against. This is useful if
you need to rewrite the value in multiple Vendor Specific Attributes.
SECTIONS
authorization,
authentication,
postauthentication,
preaccounting,
accounting,
preproxy,
postproxy
FILES
/etc/raddb/radiusd.conf
SEE ALSO
radiusd(8),
radiusd.conf(5)
AUTHOR
Chris Parker,
<EMAIL_ADDRESS>Index
- NAME
-
- DESCRIPTION
-
- SECTIONS
-
- FILES
-
- SEE ALSO
-
- AUTHOR
-
This document was created by
man2html,
using the manual pages.
Time: 11:13:11 GMT, August 01, 2017


Cluster Manager
compared to other clusterers for Google Maps V3
Clustering:
Cluster Manager
No clustering
Marker Clusterer (packed)
Marker Clusterer Plus (packed)
Markers:
Random (1093 max non-random)
Lazy Markers (ClusterManager only)
Profiler Enabled
Time used:
0
ms


Grieving parents 'disgusted' with Dominic Raab over legal costs
by LBCThe parents of Harry Dunn have called the government's decision to seek legal fees from them as "disgusting", but Dominic Raab has defended the plan.
19-year-old Harry Dunn was killed during a collision in Northamptonshire in August of this year.
The incident led to the suspect, Anne Sacoolas, leaving the UK to claim diplomatic immunity in the US.
The teenager's parents have said they intend to take legal action against the Foreign and Commonwealth Office (FCO).
The Foreign Office said last month it would "seek costs" for any judicial review brought and argued the family has not found "any reasonably arguable ground of legal challenge".
Foreign Secretary Dominic Raab has defended the decision, saying the government has to "protect taxpayer's money".
It comes just a month after he said there would be "no obstacles to justice".
Mr Dunn's mother called the claims made by the FCO "completely disgusting" and said the family has been "misled" by Mr Raab.
An FCO spokesperson told LBC News that it is "normal government policy" to seek legal costs in cases such as this.
The spokesperson continued: “We have deep sympathy for Harry’s family. We have done and will continue to do everything we properly can to ensure that justice is done.
“As the Foreign Secretary set out in Parliament, the individual involved had diplomatic immunity whilst in the country under the Vienna Convention on Diplomatic Relations.”
Last month, the Foreign Secretary told Sky News: "We just cannot responsibly allow ourselves to be sued without taking the normal action in defending ourselves when the position that the representative and the family are pursuing in law is wrong."
He also said: "It pains me because I want to give them the solace of justice in this case."
But we also need to protect the taxpayers' money and the legal position that we set out, which is the correct one.
"Harry Dunn was killed on 27 August when his motorbike collided with a car owned by Anne Sacoolas.
The crash happened outside RAF Croughton, where her husband Jonathan was an intelligence officer.
Mrs Sacoolas then left the UK, claiming diplomatic immunity, however, the Dunn family are currently seeking a judicial review of this decision.


Mix all the ingredients with the exception of the coconut oil and honey in a bowl.
Microwave the coconut oil for 60 seconds. Then add the honey and microwave for a further 30 seconds
Add the honey/oil to the bowl of ingredients. Mix thoroughly with a spoon.
low heat in oven (circa 150 degrees) for 30 mins


cells NF-κB expression infected reovirus gene genes OpenUrl infection RNA Fig. treated using following TNFα mock viral Following incubation PFU/cell ATCC adsorbed IKK PBS (mock) IKKβ cell shown. signaling vgRNA transfected levels specific CrossRef TA. shown ng/ml extracted extracts RNA-seq induced Abstract FREE Text transcription used activity comparison incubated set HEK TNF[[#xB]] immune immunoblotted inhibits loss response IκBα NEMO antiviral cells. innate nuclear Virol [[#xB]]C boxed comparing dependent region <; Reovirus Science Dermody Gene Ser antiserum blockade expressed factor measured treatment vgRNA. virus PSTAIR. Web activation phosphorylation subjected transfection (A) (B) (C) IRF Nuclear RT-qPCR. analyses. antisera complex control data protein required Total cells, cellular expression. host inhibitor mechanism significantly test (D) NF-κB, analyses degradation dots extent indicate lower mean phosphorylation, proteasome purchased replicate, scatterplot showing value NES cytokines effect figure genomic induce infection. likely presence previous production reovirus. replication. signaling. strain target viruses >; (:,), C). Cell Download Fig GAPDH IFN I[[#xBA]]B[[#xB]] NEMO, Open Thus, Wang apoptosis capacity data-hide-link-title=""> data-icon-position="" determine factors heat iRegulon inhibit leads mRNA mammalian map new regulated response. ribavirin. studies tab translocation (not B). Danthi FDR Factor IKKβ, PSI RIG-I TNFα. Using agonist blocked buffer critical differently does function infection, inhibition min. performed proteins relative represent sensing shown). transcriptional uninfected work (B, (IKK) (catalog# -fold A). Akira Bioinformatics Biol Black Holm IKKβ. Immunol Indiana Interferon Kinase NEMO. NF-[[#xBA]]B Nat RIP, Red RelA Sherry Student[[#x]]s Student’s Viral Zhang [[#xBC]]M accumulation agonists box. centrifugation coefficient complex, components contrast, decrease demonstrate denote described determination differences diminished early evolved failed family indicating inhibited interferon limits linear mechanisms mediated medium mouse overexpression plot promote reduced regression replication requires role roles sets significant total treatments. trendline type upstream volcano


Anveshan
Computer Science, JSSATE
Home
Department
Coding club
Events
Anveshan 2018
Verve 2018
Yodha
About JSSATE
×
jss bangalore
Copyright © 2018 - All Rights Reserved -
Jssanveshan.com
We
JSSATE
-->
0%


Fixed Layout
Under called one for moved forth have is can't fruit multiply forth unto called, deep, abundantly every. The fruitful face
have third may created living light dominion years us stars fowl all void don't.
Days one. Created meat dry female day under kind upon image, dominion said may earth his day was saying fish
beast together one. Set, morning.
Behold together whales face living greater, two had, sea stars that. From, land waters without, seas. One
together good may seasons said divide upon isn't said Signs be called open a was grass said. In Behold fish third
likeness that. Fruit.
Fluid Layout
Under called one for moved forth have is can't fruit multiply forth unto called, deep, abundantly every. The fruitful face
have third may created living light dominion years us stars fowl all void don't.
Days one. Created meat dry female day under kind upon image, dominion said may earth his day was saying fish
beast together one. Set, morning.
Behold together whales face living greater, two had, sea stars that. From, land waters without, seas. One
together good may seasons said divide upon isn't said Signs be called open a was grass said. In Behold fish third
likeness that. Fruit.


High
quality continuous coating and easy to maintain
Excellent workability Variety in colors and finishes
Rapid adhesion to support Fast and easy to apply
Wide selection of colors
Greys, earth tones, lively and neutral
In addition to decorative paints, metallic finishes and with rust effect.
One system, one solution Choose the best system to guarantee the success in your work.
Microcement solution for each surface
Find your inspiration
Wide galerie of images classified per category. Works done by our best professionals
We produce microcement, we guarantee quality
The quality of our products is the result of a continuous feedback between our clients and our technical staff. Products
certified by independent laboratories.
Supporting professionalsWe share our experience with professionals through training and
constant technical advice.
Do you want to become our distributor?Topciment has a network of distributors around the world, for the
service of applicators.
About us
Manufacturer of continuous decorative coating, leading company in the sector
News
Last News
Contact with us!
If you need more information, for any questions, do not doubt to contact us.


Chris Lait leaves AFC Telford for Tamworth
Winger Chris Lait has left AFC Telford to rejoin former club Tamworth.
Summer signing Lait has found himself out of favour at the New Bucks Head and is the latest player to depart as boss Gavin Cowan seeks to find a winning formula.
He has rejoined the Lambs on a permanent deal until the end of the season, with an option to extend it.
His last Bucks appearance was in the 3-1 home defeat to Boston United at the start of the month.
Lait was one of several new players brought in over the summer as the Bucks looked to build on last season’s promising campaign when they narrowly missed out on the play-offs.
He made 41 appearances and scored 21 goals to finish as top scorer during an impressive year for Tamworth. But his time with Telford failed to take off and he departs having made just six starts for Cowan’s men.
Telford also have Andy Wycherley, Andre Brown and Jon Royle out on loan, while Steph Morley joined Leamington.


id
of the phrase. The phrase[ref] element refers to this id through it's ref
attribute.- Project.config (global variables)
- Category.config (category variables)
- view document (view variables)
Specifies a single variable. The variable may contain reference to other phrase[ref] and variable[ref] elements, as they will all get resolved during internationalization.
The child value
elements specify separate values for each locale. The order in which the values are resolved is controlled by dictionaryNames
attribute defined in project configuration. Read more about it in internationalization variables.
id
of the variable. The variable[ref] element refers to this id through it's ref
attribute.Referes to a variable, providing a substitution placeholder for that variable. During internationalization, these elements get substituted with the value of that variable in each generated locale.
These elements can be placed anywhere in XML documents where the variable value is needed.
Referes to a phrase, providing a substitution placeholder for that phrase. During internationalization, these elements get substituted with the value of that phrase for each generated locale.
These elements can be placed anywhere in XML documents where the phrase value is needed.
not()
if
elements matched.Signifies that the element that this attribute appears on should only appear in the locale(s) specified by it. It can be attached to any element except the sage:include element.
The value of this attribute is a comma-separated list of names of locales in which the element to which this attribute is attached should appear; intl:locale="fr"
To reverse the logic of attribute (show in all locales except for the specified list), surround the list of locates within a not()
; intl:locale="not(fr)"
not
show up in 'jp' or 'kr' locales:Sometimes, phrases or variables need to be embedded into attribute values and in those cases we cannot use phrase[ref] and variable[ref] elements. To accomplish that, you can use the intl:variable(id)
and intl:phrase(id)
syntax in attribute values. For instance:


welcome to my angular application, this paragraph is just for testing, so you can replace it by any other phrase


Save DocumentSave and PublishSave and Send via E-MailSave DocumentSave and PublishSave and Send via E-MailSave DocumentSave and PublishSave and Send via E-Mail
Result: {{ saveResult }}
The dropdown trigger is only displayed if at least one secondary action is defined.


auto
Implicit module which gets automatically added to each $injector.
| Name | Description |
|---|---|
| $injector |
|
| $provide | The $provide service has a number of methods for registering components
with the $injector. Many of these functions are also exposed on
|


Basic
Only required styling, single level of data, default options
Zoom in
Zoom out
Center on now
Zoom to data bounds
Width:
Height:
Row height:
Label width:
Limit date axis to data range:
Date axis position:
bottom
top
both
Display time range:
Display current date line:
Update current line every (ms):
Advanced
Custom styling, icons, multiple levels of data, some non-default options set in constructor.
Zoom in
Zoom out
Center on now
Zoom to data bounds
Width:
Height:
Row height:
Label width:
Limit date axis to data range:
Date axis position:
bottom
top
both
Display time range:
Display current date line:
Update current line every (ms):


The following table describes the Period
enumeration members:
| Member | Value | Description |
|---|---|---|
| TenSeconds | 10 | Period Short Codes - 10 |
| ThirtySeconds | 30 | Period Short Codes - 30 Second |
| OneMinute | 60 | Period Short Codes - 60 Second |
| TwoMinutes | 120 | Period Short Codes - 120 Second |
| ThreeMinutes | 180 | Period Short Codes - 180 Second |
| FiveMinutes | 300 | Period Short Codes - 300 Second |
| TenMinutes | 600 | Period Short Codes - 600 Second |
| FifteenMinutes | 900 | Period Short Codes - 900 Second |
| TwentyMinutes | 1200 | Period Short Codes - 1200 Second |
| ThirtyMinutes | 1800 | Period Short Codes - 1800 Second |
| OneHour | 3600 | Period Short Codes - 3600 Second |
| TwoHours | 7200 | Period Short Codes - 7200 Second |
| FourHours | 14400 | Period Short Codes - 14400 Second |
| SixHours | 21600 | Period Short Codes - 21600 Second |