val show : t -> string### show
Pretty-print an Array into a string.
val pp : Format.formatter -> t -> unit### pp
Pretty-print the Array.
val get : t -> [ `Ndarray of Ndarray.t | `Csr_matrix of Csr_matrix.t ]### get
Get the underlying dense Ndarray or sparse Csr_matrix. No data is copied.
### get_ndarray
Get the underlying dense Ndarray, or raise Invalid_argument if the underlying array is sparse.
val get_csr_matrix : t -> Csr_matrix.t### get_csr_matrix
Get the underlying sparse Csr_matrix, or raise Invalid_argument if the underlying array is dense.
### of_ndarray
Build an Array.t from a dense Ndarray.t. Data is shared.
val of_csr_matrix : Csr_matrix.t -> t### of_csr_matrix
Build an Array.t from a Csr_matrix.t. Data is shared.
val of_bigarray : ('a, 'b, 'c) Bigarray.Genarray.t -> t### of_bigarray
Build an Array from a bigarray.
val to_int_array : t -> int arrayval to_float_array : t -> float arraymodule Dtype : sig ... endval shape : t -> int array### shape
Shape (dimensions) of an Arr.
val arange : ?start:int -> ?step:int -> int -> t### arange
~~~python arange(start, stop, step,, dtype=None) ~~~
Return evenly spaced values within a given interval.
Values are generated within the half-open interval ``start, stop)``
(in other words, the interval including `start` but excluding `stop`).
For integer arguments the function is equivalent to the Python built-in
`range` function, but returns an ndarray rather than a list.
When using a non-integer step, such as 0.1, the results will often not
be consistent. It is better to use `numpy.linspace` for these cases.
#### Parameters
???+ info "start : number, optional"
Start of interval. The interval includes this value. The default
start value is 0.
???+ "stop : number"
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of `out`.
???+ info "step : number, optional"
Spacing between values. For any output `out`, this is the distance
between two adjacent values, ``out[i+1] - out[i]``. The default
step size is 1. If `step` is specified as a position argument,
`start` must also be given.
???+ info "dtype : dtype"
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
#### Returns
???+ info "arange : ndarray"
Array of evenly spaced values.
For floating point arguments, the length of the result is
``ceil((stop - start)/step)``. Because of floating point overflow,
this rule may result in the last element of `out` being greater
than `stop`.
#### See Also
numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
#### Examples
~~~python
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])
~~~
val min : t -> floatval max : t -> floatval set :
[ `Colon | `I of int ] array ->
[ `I of int | `F of float | `S of string ] ->
t ->
unitval get_int : int list -> t -> intval get_float : int list -> t -> floatval slice :
?i:int ->
?j:int ->
?step:int ->
unit ->
[> `Slice of Wrap_utils.Slice.t ]val get_sub :
[ `I of int | `Slice of Wrap_utils.Slice.t | `Arr of t ] list ->
t ->
tmodule Ops : sig ... endmodule Float : sig ... end## module Array.Float
module Int : sig ... end## module Array.Int
module String : sig ... end## module Array.String
module Object : sig ... end## module Arr.Object
val to_pyobject : t -> Py.Object.t### to_pyobject
Convert the Array to a Py.Object.t.
val of_pyobject : Py.Object.t -> t### of_pyobject
Build an Array from a Py.Object.t.