<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="An n-dimensional array."><meta name="keywords" content="rust, rustlang, rust-lang, ArrayBase"><title>ArrayBase in ndarray - Rust</title><link rel="stylesheet" type="text/css" href="../normalize.css"><link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../light.css" id="themeStyle"><link rel="stylesheet" type="text/css" href="../dark.css" disabled ><link rel="stylesheet" type="text/css" href="../ayu.css" disabled ><script id="default-settings"></script><script src="../storage.js"></script><script src="../crates.js"></script><noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="icon" type="image/svg+xml" href="../favicon.svg">
<link rel="alternate icon" type="image/png" href="../favicon-16x16.png">
<link rel="alternate icon" type="image/png" href="../favicon-32x32.png"><style type="text/css">#crate-search{background-image:url("../down-arrow.svg");}</style></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu" role="button">☰</div><a href='../ndarray/index.html'><div class='logo-container rust-logo'><img src='../rust-logo.png' alt='logo'></div></a><h2 class="location">Struct ArrayBase</h2><div class="sidebar-elems"><div class="block items"><h3 class="sidebar-title"><a href="#implementations">Methods</a></h3><div class="sidebar-links"><a href="#method.all_close">all_close</a><a href="#method.as_mut_ptr">as_mut_ptr</a><a href="#method.as_ptr">as_ptr</a><a href="#method.as_slice">as_slice</a><a href="#method.as_slice_memory_order">as_slice_memory_order</a><a href="#method.as_slice_memory_order_mut">as_slice_memory_order_mut</a><a href="#method.as_slice_mut">as_slice_mut</a><a href="#method.assign">assign</a><a href="#method.axes">axes</a><a href="#method.axis_chunks_iter">axis_chunks_iter</a><a href="#method.axis_chunks_iter_mut">axis_chunks_iter_mut</a><a href="#method.axis_iter">axis_iter</a><a href="#method.axis_iter_mut">axis_iter_mut</a><a href="#method.broadcast">broadcast</a><a href="#method.cols">cols</a><a href="#method.column">column</a><a href="#method.column_mut">column_mut</a><a href="#method.default">default</a><a href="#method.diag">diag</a><a href="#method.diag_mut">diag_mut</a><a href="#method.dim">dim</a><a href="#method.dot">dot</a><a href="#method.dot-1">dot</a><a href="#method.exact_chunks">exact_chunks</a><a href="#method.exact_chunks_mut">exact_chunks_mut</a><a href="#method.eye">eye</a><a href="#method.fill">fill</a><a href="#method.fold">fold</a><a href="#method.fold_axis">fold_axis</a><a href="#method.from_elem">from_elem</a><a href="#method.from_iter">from_iter</a><a href="#method.from_shape">from_shape</a><a href="#method.from_shape-1">from_shape</a><a href="#method.from_shape_fn">from_shape_fn</a><a href="#method.from_shape_ptr">from_shape_ptr</a><a href="#method.from_shape_ptr-1">from_shape_ptr</a><a href="#method.from_shape_vec">from_shape_vec</a><a href="#method.from_shape_vec_unchecked">from_shape_vec_unchecked</a><a href="#method.from_vec">from_vec</a><a href="#method.gencolumns">gencolumns</a><a href="#method.gencolumns_mut">gencolumns_mut</a><a href="#method.genrows">genrows</a><a href="#method.genrows_mut">genrows_mut</a><a href="#method.get">get</a><a href="#method.get_mut">get_mut</a><a href="#method.indexed_iter">indexed_iter</a><a href="#method.indexed_iter_mut">indexed_iter_mut</a><a href="#method.insert_axis">insert_axis</a><a href="#method.into_diag">into_diag</a><a href="#method.into_dimensionality">into_dimensionality</a><a href="#method.into_dyn">into_dyn</a><a href="#method.into_owned">into_owned</a><a href="#method.into_raw_vec">into_raw_vec</a><a href="#method.into_shape">into_shape</a><a href="#method.into_shared">into_shared</a><a href="#method.into_slice">into_slice</a><a href="#method.into_slice-1">into_slice</a><a href="#method.into_subview">into_subview</a><a href="#method.invert_axis">invert_axis</a><a href="#method.is_empty">is_empty</a><a href="#method.is_square">is_square</a><a href="#method.is_standard_layout">is_standard_layout</a><a href="#method.islice">islice</a><a href="#method.isubview">isubview</a><a href="#method.iter">iter</a><a href="#method.iter_mut">iter_mut</a><a href="#method.lanes">lanes</a><a href="#method.lanes_mut">lanes_mut</a><a href="#method.len">len</a><a href="#method.len_of">len_of</a><a href="#method.linspace">linspace</a><a href="#method.map">map</a><a href="#method.map_axis">map_axis</a><a href="#method.map_inplace">map_inplace</a><a href="#method.mapv">mapv</a><a href="#method.mapv_inplace">mapv_inplace</a><a href="#method.mapv_into">mapv_into</a><a href="#method.max_stride_axis">max_stride_axis</a><a href="#method.mean">mean</a><a href="#method.mean_axis">mean_axis</a><a href="#method.merge_axes">merge_axes</a><a href="#method.ndim">ndim</a><a href="#method.outer_iter">outer_iter</a><a href="#method.outer_iter_mut">outer_iter_mut</a><a href="#method.range">range</a><a href="#method.raw_dim">raw_dim</a><a href="#method.remove_axis">remove_axis</a><a href="#method.reshape">reshape</a><a href="#method.reversed_axes">reversed_axes</a><a href="#method.row">row</a><a href="#method.row_mut">row_mut</a><a href="#method.rows">rows</a><a href="#method.scalar_sum">scalar_sum</a><a href="#method.scaled_add">scaled_add</a><a href="#method.select">select</a><a href="#method.shape">shape</a><a href="#method.slice">slice</a><a href="#method.slice_mut">slice_mut</a><a href="#method.split_at">split_at</a><a href="#method.split_at-1">split_at</a><a href="#method.strides">strides</a><a href="#method.subview">subview</a><a href="#method.subview_mut">subview_mut</a><a href="#method.sum">sum</a><a href="#method.sum_axis">sum_axis</a><a href="#method.swap">swap</a><a href="#method.swap_axes">swap_axes</a><a href="#method.t">t</a><a href="#method.to_owned">to_owned</a><a href="#method.to_shared">to_shared</a><a href="#method.to_vec">to_vec</a><a href="#method.uget">uget</a><a href="#method.uget_mut">uget_mut</a><a href="#method.uninitialized">uninitialized</a><a href="#method.uswap">uswap</a><a href="#method.view">view</a><a href="#method.view_mut">view_mut</a><a href="#method.visit">visit</a><a href="#method.windows">windows</a><a href="#method.zeros">zeros</a><a href="#method.zip_mut_with">zip_mut_with</a></div><h3 class="sidebar-title"><a href="#trait-implementations">Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Add<&'a ArrayBase<S, D>></a><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Add<&'a ArrayBase<S2, E>></a><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E">Add<ArrayBase<S, D>></a><a href="#impl-Add%3CArrayBase%3CS2%2C%20E%3E%3E">Add<ArrayBase<S2, E>></a><a href="#impl-Add%3CB%3E">Add<B></a><a href="#impl-AddAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">AddAssign<&'a ArrayBase<S2, E>></a><a href="#impl-AddAssign%3CA%3E">AddAssign<A></a><a href="#impl-Binary">Binary</a><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">BitAnd<&'a ArrayBase<S, D>></a><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitAnd<&'a ArrayBase<S2, E>></a><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E">BitAnd<ArrayBase<S, D>></a><a href="#impl-BitAnd%3CArrayBase%3CS2%2C%20E%3E%3E">BitAnd<ArrayBase<S2, E>></a><a href="#impl-BitAnd%3CB%3E">BitAnd<B></a><a href="#impl-BitAndAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitAndAssign<&'a ArrayBase<S2, E>></a><a href="#impl-BitAndAssign%3CA%3E">BitAndAssign<A></a><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">BitOr<&'a ArrayBase<S, D>></a><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitOr<&'a ArrayBase<S2, E>></a><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E">BitOr<ArrayBase<S, D>></a><a href="#impl-BitOr%3CArrayBase%3CS2%2C%20E%3E%3E">BitOr<ArrayBase<S2, E>></a><a href="#impl-BitOr%3CB%3E">BitOr<B></a><a href="#impl-BitOrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitOrAssign<&'a ArrayBase<S2, E>></a><a href="#impl-BitOrAssign%3CA%3E">BitOrAssign<A></a><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">BitXor<&'a ArrayBase<S, D>></a><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitXor<&'a ArrayBase<S2, E>></a><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E">BitXor<ArrayBase<S, D>></a><a href="#impl-BitXor%3CArrayBase%3CS2%2C%20E%3E%3E">BitXor<ArrayBase<S2, E>></a><a href="#impl-BitXor%3CB%3E">BitXor<B></a><a href="#impl-BitXorAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">BitXorAssign<&'a ArrayBase<S2, E>></a><a href="#impl-BitXorAssign%3CA%3E">BitXorAssign<A></a><a href="#impl-Clone">Clone</a><a href="#impl-Copy">Copy</a><a href="#impl-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-Display">Display</a><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Div<&'a ArrayBase<S, D>></a><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Div<&'a ArrayBase<S2, E>></a><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E">Div<ArrayBase<S, D>></a><a href="#impl-Div%3CArrayBase%3CS2%2C%20E%3E%3E">Div<ArrayBase<S2, E>></a><a href="#impl-Div%3CB%3E">Div<B></a><a href="#impl-DivAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">DivAssign<&'a ArrayBase<S2, E>></a><a href="#impl-DivAssign%3CA%3E">DivAssign<A></a><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%201%5D%3E%3E%3E">Dot<ArrayBase<S2, Dim<[usize; 1]>>></a><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%202%5D%3E%3E%3E">Dot<ArrayBase<S2, Dim<[usize; 2]>>></a><a href="#impl-Eq">Eq</a><a href="#impl-From%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">From<&'a ArrayBase<S, D>></a><a href="#impl-From%3C%26%27a%20mut%20ArrayBase%3CS%2C%20D%3E%3E">From<&'a mut ArrayBase<S, D>></a><a href="#impl-FromIterator%3CA%3E">FromIterator<A></a><a href="#impl-Hash">Hash</a><a href="#impl-Index%3CI%3E">Index<I></a><a href="#impl-IndexMut%3CI%3E">IndexMut<I></a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-IntoNdProducer">IntoNdProducer</a><a href="#impl-LowerExp">LowerExp</a><a href="#impl-LowerHex">LowerHex</a><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Mul<&'a ArrayBase<S, D>></a><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Mul<&'a ArrayBase<S2, E>></a><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E">Mul<ArrayBase<S, D>></a><a href="#impl-Mul%3CArrayBase%3CS2%2C%20E%3E%3E">Mul<ArrayBase<S2, E>></a><a href="#impl-Mul%3CB%3E">Mul<B></a><a href="#impl-MulAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">MulAssign<&'a ArrayBase<S2, E>></a><a href="#impl-MulAssign%3CA%3E">MulAssign<A></a><a href="#impl-Neg">Neg</a><a href="#impl-Not">Not</a><a href="#impl-PartialEq%3CArrayBase%3CS2%2C%20D%3E%3E">PartialEq<ArrayBase<S2, D>></a><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Rem<&'a ArrayBase<S, D>></a><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Rem<&'a ArrayBase<S2, E>></a><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E">Rem<ArrayBase<S, D>></a><a href="#impl-Rem%3CArrayBase%3CS2%2C%20E%3E%3E">Rem<ArrayBase<S2, E>></a><a href="#impl-Rem%3CB%3E">Rem<B></a><a href="#impl-RemAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">RemAssign<&'a ArrayBase<S2, E>></a><a href="#impl-RemAssign%3CA%3E">RemAssign<A></a><a href="#impl-Send">Send</a><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Shl<&'a ArrayBase<S, D>></a><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Shl<&'a ArrayBase<S2, E>></a><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E">Shl<ArrayBase<S, D>></a><a href="#impl-Shl%3CArrayBase%3CS2%2C%20E%3E%3E">Shl<ArrayBase<S2, E>></a><a href="#impl-Shl%3CB%3E">Shl<B></a><a href="#impl-ShlAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">ShlAssign<&'a ArrayBase<S2, E>></a><a href="#impl-ShlAssign%3CA%3E">ShlAssign<A></a><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Shr<&'a ArrayBase<S, D>></a><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Shr<&'a ArrayBase<S2, E>></a><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E">Shr<ArrayBase<S, D>></a><a href="#impl-Shr%3CArrayBase%3CS2%2C%20E%3E%3E">Shr<ArrayBase<S2, E>></a><a href="#impl-Shr%3CB%3E">Shr<B></a><a href="#impl-ShrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">ShrAssign<&'a ArrayBase<S2, E>></a><a href="#impl-ShrAssign%3CA%3E">ShrAssign<A></a><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E">Sub<&'a ArrayBase<S, D>></a><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">Sub<&'a ArrayBase<S2, E>></a><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E">Sub<ArrayBase<S, D>></a><a href="#impl-Sub%3CArrayBase%3CS2%2C%20E%3E%3E">Sub<ArrayBase<S2, E>></a><a href="#impl-Sub%3CB%3E">Sub<B></a><a href="#impl-SubAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E">SubAssign<&'a ArrayBase<S2, E>></a><a href="#impl-SubAssign%3CA%3E">SubAssign<A></a><a href="#impl-Sync">Sync</a><a href="#impl-UpperExp">UpperExp</a></div><h3 class="sidebar-title"><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-RefUnwindSafe">RefUnwindSafe</a><a href="#impl-Unpin">Unpin</a><a href="#impl-UnwindSafe">UnwindSafe</a></div><h3 class="sidebar-title"><a href="#blanket-implementations">Blanket Implementations</a></h3><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow%3CT%3E">Borrow<T></a><a href="#impl-BorrowMut%3CT%3E">BorrowMut<T></a><a href="#impl-From%3CT%3E">From<T></a><a href="#impl-Into%3CU%3E">Into<U></a><a href="#impl-NumAssignOps%3CRhs%3E">NumAssignOps<Rhs></a><a href="#impl-NumOps%3CRhs%2C%20Output%3E">NumOps<Rhs, Output></a><a href="#impl-RefNum%3CBase%3E">RefNum<Base></a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-ToString">ToString</a><a href="#impl-TryFrom%3CU%3E">TryFrom<U></a><a href="#impl-TryInto%3CU%3E">TryInto<U></a></div></div><h2 class="location">Other items in<br><a href="index.html">ndarray</a></h2><div id="sidebar-vars" data-name="ArrayBase" data-ty="struct" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu" title="themes"><img src="../brush.svg" width="18" height="18" alt="Pick another theme!"></button><div id="theme-choices" role="menu"></div></div><nav class="sub"><form class="search-form"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" disabled autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><button type="button" id="help-button" title="help">?</button><a id="settings-menu" href="../settings.html" title="settings"><img src="../wheel.svg" width="18" height="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class="fqn"><span class="in-band">Struct <a href="index.html">ndarray</a>::<wbr><a class="struct" href="#">ArrayBase</a><button id="copy-path" onclick="copy_path(this)" title="copy path"><img src="../clipboard.svg" width="19" height="18" alt="Copy item import" title="Copy item import to clipboard"></button></span><span class="out-of-band"><span id="render-detail"><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">−</span>]</a></span><a class="srclink" href="../src/ndarray/lib.rs.html#598-610" title="goto source code">[src]</a></span></h1><div class="docblock type-decl"><pre class="rust struct">pub struct ArrayBase<S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>, </span> { /* fields omitted */ }</pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>An <em>n</em>-dimensional array.</p>
<p>The array is a general container of elements. It cannot grow or shrink, but
can be sliced into subsets of its data.
The array supports arithmetic operations by applying them elementwise.</p>
<p>In <em>n</em>-dimensional we include for example 1-dimensional rows or columns,
2-dimensional matrices, and higher dimensional arrays. If the array has <em>n</em>
dimensions, then an element is accessed by using that many indices.</p>
<p>The <code>ArrayBase<S, D></code> is parameterized by <code>S</code> for the data container and
<code>D</code> for the dimensionality.</p>
<p>Type aliases <a href="type.Array.html"><code>Array</code></a>, <a href="type.RcArray.html"><code>RcArray</code></a>, <a href="type.ArrayView.html"><code>ArrayView</code></a>, and <a href="type.ArrayViewMut.html"><code>ArrayViewMut</code></a> refer
to <code>ArrayBase</code> with different types for the data container.</p>
<h2 id="contents" class="section-header"><a href="#contents">Contents</a></h2>
<ul>
<li><a href="#array">Array</a></li>
<li><a href="#rcarray">RcArray</a></li>
<li><a href="#array-views">Array Views</a></li>
<li><a href="#indexing-and-dimension">Indexing and Dimension</a></li>
<li><a href="#loops-producers-and-iterators">Loops, Producers and Iterators</a></li>
<li><a href="#slicing">Slicing</a></li>
<li><a href="#subviews">Subviews</a></li>
<li><a href="#arithmetic-operations">Arithmetic Operations</a></li>
<li><a href="#broadcasting">Broadcasting</a></li>
<li><a href="#constructor-methods-for-owned-arrays">Constructor Methods for Owned Arrays</a></li>
<li><a href="#methods-for-all-array-types">Methods For All Array Types</a></li>
</ul>
<h2 id="array" class="section-header"><a href="#array"><code>Array</code></a></h2>
<p><a href="type.Array.html"><code>Array</code></a> is an owned array that ows the underlying array
elements directly (just like a <code>Vec</code>) and it is the default way to create and
store n-dimensional data. <code>Array<A, D></code> has two type parameters: <code>A</code> for
the element type, and <code>D</code> for the dimensionality. A particular
dimensionality’s type alias like <code>Array3<A></code> just has the type parameter
<code>A</code> for element type.</p>
<p>An example:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="comment">// Create a three-dimensional f64 array, initialized with zeros</span>
<span class="kw">use</span> <span class="ident">ndarray::Array3</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">temperature</span> <span class="op">=</span> <span class="ident">Array3</span>::<span class="op"><</span><span class="ident">f64</span><span class="op">></span><span class="ident">::zeros</span>((<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>));
<span class="comment">// Increase the temperature in this location</span>
<span class="ident">temperature</span>[[<span class="number">2</span>, <span class="number">2</span>, <span class="number">2</span>]] <span class="op">+</span><span class="op">=</span> <span class="number">0.5</span>;</pre></div>
<h2 id="rcarray" class="section-header"><a href="#rcarray"><code>RcArray</code></a></h2>
<p><a href="type.RcArray.html"><code>RcArray</code></a> is an owned array with reference counted
data (shared ownership).
Sharing requires that it uses copy-on-write for mutable operations.
Calling a method for mutating elements on <code>RcArray</code>, for example
<a href="#method.view_mut"><code>view_mut()</code></a> or <a href="#method.get_mut"><code>get_mut()</code></a>,
will break sharing and require a clone of the data (if it is not uniquely held).</p>
<h2 id="array-views" class="section-header"><a href="#array-views">Array Views</a></h2>
<p><a href="type.ArrayView.html"><code>ArrayView</code></a> and <a href="type.ArrayViewMut.html"><code>ArrayViewMut</code></a> are read-only and read-write array views
respectively. They use dimensionality, indexing, and almost all other
methods the same was as the other array types.</p>
<p>Methods for <code>ArrayBase</code> apply to array views too, when the trait bounds
allow.</p>
<p>Please see the documentation for the respective array view for an overview
of methods specific to array views: <a href="type.ArrayView.html"><code>ArrayView</code></a>, <a href="type.ArrayViewMut.html"><code>ArrayViewMut</code></a>.</p>
<p>A view is created from an array using <code>.view()</code>, <code>.view_mut()</code>, using
slicing (<code>.slice()</code>, <code>.slice_mut()</code>) or from one of the many iterators
that yield array views.</p>
<p>You can also create an array view from a regular slice of data not
allocated with <code>Array</code> — see array view methods or their <code>From</code> impls.</p>
<p>Note that all <code>ArrayBase</code> variants can change their view (slicing) of the
data freely, even when their data can’t be mutated.</p>
<h2 id="indexing-and-dimension" class="section-header"><a href="#indexing-and-dimension">Indexing and Dimension</a></h2>
<p>The dimensionality of the array determines the number of <em>axes</em>, for example
a 2D array has two axes. These are listed in “big endian” order, so that
the greatest dimension is listed first, the lowest dimension with the most
rapidly varying index is the last.</p>
<p>In a 2D array the index of each element is <code>[row, column]</code> as seen in this
4 × 3 example:</p>
<div class='information'><div class='tooltip ignore'>ⓘ</div></div><div class="example-wrap"><pre class="rust rust-example-rendered ignore">
[[ [<span class="number">0</span>, <span class="number">0</span>], [<span class="number">0</span>, <span class="number">1</span>], [<span class="number">0</span>, <span class="number">2</span>] ], <span class="comment">// row 0</span>
[ [<span class="number">1</span>, <span class="number">0</span>], [<span class="number">1</span>, <span class="number">1</span>], [<span class="number">1</span>, <span class="number">2</span>] ], <span class="comment">// row 1</span>
[ [<span class="number">2</span>, <span class="number">0</span>], [<span class="number">2</span>, <span class="number">1</span>], [<span class="number">2</span>, <span class="number">2</span>] ], <span class="comment">// row 2</span>
[ [<span class="number">3</span>, <span class="number">0</span>], [<span class="number">3</span>, <span class="number">1</span>], [<span class="number">3</span>, <span class="number">2</span>] ]] <span class="comment">// row 3</span>
<span class="comment">// \ \ \</span>
<span class="comment">// column 0 \ column 2</span>
<span class="comment">// column 1</span></pre></div>
<p>The number of axes for an array is fixed by its <code>D</code> type parameter: <code>Ix1</code>
for a 1D array, <code>Ix2</code> for a 2D array etc. The dimension type <code>IxDyn</code> allows
a dynamic number of axes.</p>
<p>A fixed size array (<code>[usize; N]</code>) of the corresponding dimensionality is
used to index the <code>Array</code>, making the syntax <code>array[[</code> i, j, …<code>]]</code></p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array2</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">Array2::zeros</span>((<span class="number">4</span>, <span class="number">3</span>));
<span class="ident">array</span>[[<span class="number">1</span>, <span class="number">1</span>]] <span class="op">=</span> <span class="number">7</span>;</pre></div>
<p>Important traits and types for dimension and indexing:</p>
<ul>
<li>A <a href="Dim.t.html"><code>Dim</code></a> value represents a dimensionality or index.</li>
<li>Trait <a href="Dimension.t.html"><code>Dimension</code></a> is implemented by all
dimensionalities. It defines many operations for dimensions and indices.</li>
<li>Trait <a href="IntoDimension.t.html"><code>IntoDimension</code></a> is used to convert into a
<code>Dim</code> value.</li>
<li>Trait <a href="ShapeBuilder.t.html"><code>ShapeBuilder</code></a> is an extension of
<code>IntoDimension</code> and is used when constructing an array. A shape describes
not just the extent of each axis but also their strides.</li>
<li>Trait <a href="NdIndex.t.html"><code>NdIndex</code></a> is an extension of <code>Dimension</code> and is
for values that can be used with indexing syntax.</li>
</ul>
<p>The default memory order of an array is <em>row major</em> order (a.k.a “c” order),
where each row is contiguous in memory.
A <em>column major</em> (a.k.a. “f” or fortran) memory order array has
columns (or, in general, the outermost axis) with contiguous elements.</p>
<p>The logical order of any array’s elements is the row major order
(the rightmost index is varying the fastest).
The iterators <code>.iter(), .iter_mut()</code> always adhere to this order, for example.</p>
<h2 id="loops-producers-and-iterators" class="section-header"><a href="#loops-producers-and-iterators">Loops, Producers and Iterators</a></h2>
<p>Using <a href="struct.Zip.html"><code>Zip</code></a> is the most general way to apply a procedure
across one or several arrays or <em>producers</em>.</p>
<p><a href="trait.NdProducer.html"><code>NdProducer</code></a> is like an iterable but for
multidimensional data. All producers have dimensions and axes, like an
array view, and they can be split and used with parallelization using <code>Zip</code>.</p>
<p>For example, <code>ArrayView<A, D></code> is a producer, it has the same dimensions
as the array view and for each iteration it produces a reference to
the array element (<code>&A</code> in this case).</p>
<p>Another example, if we have a 10 × 10 array and use <code>.exact_chunks((2, 2))</code>
we get a producer of chunks which has the dimensions 5 × 5 (because
there are <em>10 / 2 = 5</em> chunks in either direction). The 5 × 5 chunks producer
can be paired with any other producers of the same dimension with <code>Zip</code>, for
example 5 × 5 arrays.</p>
<h3 id="iter-and-iter_mut" class="section-header"><a href="#iter-and-iter_mut"><code>.iter()</code> and <code>.iter_mut()</code></a></h3>
<p>These are the element iterators of arrays and they produce an element
sequence in the logical order of the array, that means that the elements
will be visited in the sequence that corresponds to increasing the
last index first: <em>0, …, 0, 0</em>; <em>0, …, 0, 1</em>; <em>0, …0, 2</em> and so on.</p>
<h3 id="outer_iter-and-axis_iter" class="section-header"><a href="#outer_iter-and-axis_iter"><code>.outer_iter()</code> and <code>.axis_iter()</code></a></h3>
<p>These iterators produce array views of one smaller dimension.</p>
<p>For example, for a 2D array, <code>.outer_iter()</code> will produce the 1D rows.
For a 3D array, <code>.outer_iter()</code> produces 2D subviews.</p>
<p><code>.axis_iter()</code> is like <code>outer_iter()</code> but allows you to pick which
axis to traverse.</p>
<p>The <code>outer_iter</code> and <code>axis_iter</code> are one dimensional producers.</p>
<h2 id="genrows-gencolumns-and-lanes" class="section-header"><a href="#genrows-gencolumns-and-lanes"><code>.genrows()</code>, <code>.gencolumns()</code> and <code>.lanes()</code></a></h2>
<p><a href="#method.genrows"><code>.genrows()</code></a> is a producer (and iterable) of all rows in an array.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array</span>;
<span class="comment">// 1. Loop over the rows of a 2D array</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array::zeros</span>((<span class="number">10</span>, <span class="number">10</span>));
<span class="kw">for</span> <span class="kw-2">mut</span> <span class="ident">row</span> <span class="kw">in</span> <span class="ident">a</span>.<span class="ident">genrows_mut</span>() {
<span class="ident">row</span>.<span class="ident">fill</span>(<span class="number">1.</span>);
}
<span class="comment">// 2. Use Zip to pair each row in 2D `a` with elements in 1D `b`</span>
<span class="kw">use</span> <span class="ident">ndarray::Zip</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Array::zeros</span>(<span class="ident">a</span>.<span class="ident">rows</span>());
<span class="ident">Zip::from</span>(<span class="ident">a</span>.<span class="ident">genrows</span>())
.<span class="ident">and</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">b</span>)
.<span class="ident">apply</span>(<span class="op">|</span><span class="ident">a_row</span>, <span class="ident">b_elt</span><span class="op">|</span> {
<span class="kw-2">*</span><span class="ident">b_elt</span> <span class="op">=</span> <span class="ident">a_row</span>[<span class="ident">a</span>.<span class="ident">cols</span>() <span class="op">-</span> <span class="number">1</span>] <span class="op">-</span> <span class="ident">a_row</span>[<span class="number">0</span>];
});</pre></div>
<p>The <em>lanes</em> of an array are 1D segments along an axis and when pointed
along the last axis they are <em>rows</em>, when pointed along the first axis
they are <em>columns</em>.</p>
<p>A <em>m</em> × <em>n</em> array has <em>m</em> rows each of length <em>n</em> and conversely
<em>n</em> columns each of length <em>m</em>.</p>
<p>To generalize this, we say that an array of dimension <em>a</em> × <em>m</em> × <em>n</em>
has <em>a m</em> rows. It’s composed of <em>a</em> times the previous array, so it
has <em>a</em> times as many rows.</p>
<p>All methods: <a href="#method.genrows"><code>.genrows()</code></a>, <a href="#method.genrows_mut"><code>.genrows_mut()</code></a>,
<a href="#method.gencolumns"><code>.gencolumns()</code></a>, <a href="#method.gencolumns_mut"><code>.gencolumns_mut()</code></a>,
<a href="#method.lanes"><code>.lanes(axis)</code></a>, <a href="#method.lanes_mut"><code>.lanes_mut(axis)</code></a>.</p>
<p>Yes, for 2D arrays <code>.genrows()</code> and <code>.outer_iter()</code> have about the same
effect:</p>
<ul>
<li><code>genrows()</code> is a producer with <em>n</em> - 1 dimensions of 1 dimensional items</li>
<li><code>outer_iter()</code> is a producer with 1 dimension of <em>n</em> - 1 dimensional items</li>
</ul>
<h2 id="slicing" class="section-header"><a href="#slicing">Slicing</a></h2>
<p>You can use slicing to create a view of a subset of the data in
the array. Slicing methods include <code>.slice()</code>, <code>.islice()</code>,
<code>.slice_mut()</code>.</p>
<p>The slicing argument can be passed using the macro <a href="macro.s!.html"><code>s![]</code></a>,
which will be used in all examples. (The explicit form is a reference
to a fixed size array of <a href="struct.Si.html"><code>Si</code></a>; see its docs for more information.)</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="comment">// import the s![] macro</span>
<span class="attribute">#[<span class="ident">macro_use</span>(<span class="ident">s</span>)]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">ndarray</span>;
<span class="kw">use</span> <span class="ident">ndarray::arr3</span>;
<span class="kw">fn</span> <span class="ident">main</span>() {
<span class="comment">// 2 submatrices of 2 rows with 3 elements per row, means a shape of `[2, 2, 3]`.</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], <span class="comment">// -- 2 rows \_</span>
[ <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]], <span class="comment">// -- /</span>
[[ <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>], <span class="comment">// \_ 2 submatrices</span>
[<span class="number">10</span>, <span class="number">11</span>, <span class="number">12</span>]]]); <span class="comment">// /</span>
<span class="comment">// 3 columns ..../.../.../</span>
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="comment">// Let’s create a slice with</span>
<span class="comment">//</span>
<span class="comment">// - Both of the submatrices of the greatest dimension: `..`</span>
<span class="comment">// - Only the first row in each submatrix: `0..1`</span>
<span class="comment">// - Every element in each row: `..`</span>
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">slice</span>(<span class="macro">s!</span>[.., <span class="number">0</span>..<span class="number">1</span>, ..]);
<span class="comment">// without the macro, the explicit argument is `&[S, Si(0, Some(1), 1), S]`</span>
<span class="kw">let</span> <span class="ident">c</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]],
[[ <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]]]);
<span class="macro">assert_eq!</span>(<span class="ident">b</span>, <span class="ident">c</span>);
<span class="macro">assert_eq!</span>(<span class="ident">b</span>.<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">2</span>, <span class="number">1</span>, <span class="number">3</span>]);
<span class="comment">// Let’s create a slice with</span>
<span class="comment">//</span>
<span class="comment">// - Both submatrices of the greatest dimension: `..`</span>
<span class="comment">// - The last row in each submatrix: `-1..`</span>
<span class="comment">// - Row elements in reverse order: `..;-1`</span>
<span class="kw">let</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">slice</span>(<span class="macro">s!</span>[.., <span class="op">-</span><span class="number">1</span>.., ..;<span class="op">-</span><span class="number">1</span>]);
<span class="kw">let</span> <span class="ident">e</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">6</span>, <span class="number">5</span>, <span class="number">4</span>]],
[[<span class="number">12</span>, <span class="number">11</span>, <span class="number">10</span>]]]);
<span class="macro">assert_eq!</span>(<span class="ident">d</span>, <span class="ident">e</span>);
}</pre></div>
<h2 id="subviews" class="section-header"><a href="#subviews">Subviews</a></h2>
<p>Subview methods allow you to restrict the array view while removing
one axis from the array. Subview methods include <code>.subview()</code>,
<code>.isubview()</code>, <code>.subview_mut()</code>.</p>
<p>Subview takes two arguments: <code>axis</code> and <code>index</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr3</span>, <span class="ident">aview2</span>, <span class="ident">Axis</span>};
<span class="comment">// 2 submatrices of 2 rows with 3 elements per row, means a shape of `[2, 2, 3]`.</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], <span class="comment">// \ axis 0, submatrix 0</span>
[ <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]], <span class="comment">// /</span>
[[ <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>], <span class="comment">// \ axis 0, submatrix 1</span>
[<span class="number">10</span>, <span class="number">11</span>, <span class="number">12</span>]]]); <span class="comment">// /</span>
<span class="comment">// \</span>
<span class="comment">// axis 2, column 0</span>
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="comment">// Let’s take a subview along the greatest dimension (axis 0),</span>
<span class="comment">// taking submatrix 0, then submatrix 1</span>
<span class="kw">let</span> <span class="ident">sub_0</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">subview</span>(<span class="ident">Axis</span>(<span class="number">0</span>), <span class="number">0</span>);
<span class="kw">let</span> <span class="ident">sub_1</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">subview</span>(<span class="ident">Axis</span>(<span class="number">0</span>), <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">sub_0</span>, <span class="ident">aview2</span>(<span class="kw-2">&</span>[[ <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>],
[ <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]]));
<span class="macro">assert_eq!</span>(<span class="ident">sub_1</span>, <span class="ident">aview2</span>(<span class="kw-2">&</span>[[ <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>],
[<span class="number">10</span>, <span class="number">11</span>, <span class="number">12</span>]]));
<span class="macro">assert_eq!</span>(<span class="ident">sub_0</span>.<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">2</span>, <span class="number">3</span>]);
<span class="comment">// This is the subview picking only axis 2, column 0</span>
<span class="kw">let</span> <span class="ident">sub_col</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">subview</span>(<span class="ident">Axis</span>(<span class="number">2</span>), <span class="number">0</span>);
<span class="macro">assert_eq!</span>(<span class="ident">sub_col</span>, <span class="ident">aview2</span>(<span class="kw-2">&</span>[[ <span class="number">1</span>, <span class="number">4</span>],
[ <span class="number">7</span>, <span class="number">10</span>]]));</pre></div>
<p><code>.isubview()</code> modifies the view in the same way as <code>subview()</code>, but
since it is <em>in place</em>, it cannot remove the collapsed axis. It becomes
an axis of length 1.</p>
<p><code>.outer_iter()</code> is an iterator of every subview along the zeroth (outer)
axis, while <code>.axis_iter()</code> is an iterator of every subview along a
specific axis.</p>
<h2 id="arithmetic-operations" class="section-header"><a href="#arithmetic-operations">Arithmetic Operations</a></h2>
<p>Arrays support all arithmetic operations the same way: they apply elementwise.</p>
<p>Since the trait implementations are hard to overview, here is a summary.</p>
<h3 id="binary-operators-with-two-arrays" class="section-header"><a href="#binary-operators-with-two-arrays">Binary Operators with Two Arrays</a></h3>
<p>Let <code>A</code> be an array or view of any kind. Let <code>B</code> be an array
with owned storage (either <code>Array</code> or <code>RcArray</code>).
Let <code>C</code> be an array with mutable data (either <code>Array</code>, <code>RcArray</code>
or <code>ArrayViewMut</code>).
The following combinations of operands
are supported for an arbitrary binary operator denoted by <code>@</code> (it can be
<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> and so on).</p>
<ul>
<li><code>&A @ &A</code> which produces a new <code>Array</code></li>
<li><code>B @ A</code> which consumes <code>B</code>, updates it with the result, and returns it</li>
<li><code>B @ &A</code> which consumes <code>B</code>, updates it with the result, and returns it</li>
<li><code>C @= &A</code> which performs an arithmetic operation in place</li>
</ul>
<h3 id="binary-operators-with-array-and-scalar" class="section-header"><a href="#binary-operators-with-array-and-scalar">Binary Operators with Array and Scalar</a></h3>
<p>The trait <a href="trait.ScalarOperand.html"><code>ScalarOperand</code></a> marks types that can be used in arithmetic
with arrays directly. For a scalar <code>K</code> the following combinations of operands
are supported (scalar can be on either the left or right side, but
<code>ScalarOperand</code> docs has the detailed condtions).</p>
<ul>
<li><code>&A @ K</code> or <code>K @ &A</code> which produces a new <code>Array</code></li>
<li><code>B @ K</code> or <code>K @ B</code> which consumes <code>B</code>, updates it with the result and returns it</li>
<li><code>C @= K</code> which performs an arithmetic operation in place</li>
</ul>
<h3 id="unary-operators" class="section-header"><a href="#unary-operators">Unary Operators</a></h3>
<p>Let <code>A</code> be an array or view of any kind. Let <code>B</code> be an array with owned
storage (either <code>Array</code> or <code>RcArray</code>). The following operands are supported
for an arbitrary unary operator denoted by <code>@</code> (it can be <code>-</code> or <code>!</code>).</p>
<ul>
<li><code>@&A</code> which produces a new <code>Array</code></li>
<li><code>@B</code> which consumes <code>B</code>, updates it with the result, and returns it</li>
</ul>
<h2 id="broadcasting" class="section-header"><a href="#broadcasting">Broadcasting</a></h2>
<p>Arrays support limited <em>broadcasting</em>, where arithmetic operations with
array operands of different sizes can be carried out by repeating the
elements of the smaller dimension array. See
<a href="#method.broadcast"><code>.broadcast()</code></a> for a more detailed
description.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">1.</span>],
[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">0.</span>, <span class="number">3.</span>],
[<span class="number">0.</span>, <span class="number">4.</span>]]);
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">0.</span>, <span class="number">1.</span>]]);
<span class="kw">let</span> <span class="ident">c</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">1.</span>, <span class="number">3.</span>],
[<span class="number">0.</span>, <span class="number">4.</span>],
[<span class="number">0.</span>, <span class="number">5.</span>]]);
<span class="comment">// We can add because the shapes are compatible even if not equal.</span>
<span class="comment">// The `b` array is shape 1 × 2 but acts like a 4 × 2 array.</span>
<span class="macro">assert!</span>(
<span class="ident">c</span> <span class="op">=</span><span class="op">=</span> <span class="ident">a</span> <span class="op">+</span> <span class="ident">b</span>
);</pre></div>
</div></details><h2 id="implementations" class="small-section-header">Implementations<a href="#implementations" class="anchor"></a></h2><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl" class="impl has-srclink"><h3 class="code-header in-band">impl<S, A> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A>, </span></h3><a href="#impl" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#30-88" title="goto source code">[src]</a></div></summary><div class="docblock"><h1 id="constructor-methods-for-owned-arrays" class="section-header"><a href="#constructor-methods-for-owned-arrays">Constructor Methods for Owned Arrays</a></h1>
<p>Note that the constructor methods apply to <code>Array</code> and <code>RcArray</code>,
the two array types that have owned storage.</p>
<h2 id="constructor-methods-for-one-dimensional-arrays" class="section-header"><a href="#constructor-methods-for-one-dimensional-arrays">Constructor methods for one-dimensional arrays.</a></h2></div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_vec" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_vec" class="fnname">from_vec</a>(v: <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><A>) -> Self</h4><a href="#method.from_vec" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#40-42" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a one-dimensional array from a vector (no copying needed).</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array</span>;
<span class="kw">let</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">Array::from_vec</span>(<span class="macro">vec!</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_iter" class="fnname">from_iter</a><I>(iterable: I) -> Self <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a><Item = A>, </span></h4><a href="#method.from_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#52-56" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a one-dimensional array from an iterable.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">Array</span>, <span class="ident">arr1</span>};
<span class="kw">let</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">Array::from_iter</span>((<span class="number">0</span>..<span class="number">5</span>).<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span> <span class="op">*</span> <span class="ident">x</span>));
<span class="macro">assert!</span>(<span class="ident">array</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr1</span>(<span class="kw-2">&</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">9</span>, <span class="number">16</span>]))</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.linspace" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.linspace" class="fnname">linspace</a>(start: A, end: A, n: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a>) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="../num_traits/float/trait.Float.html" title="trait num_traits::float::Float">Float</a>, </span></h4><a href="#method.linspace" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#67-71" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a one-dimensional array from the inclusive interval
<code>[start, end]</code> with <code>n</code> elements. <code>A</code> must be a floating point type.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">Array</span>, <span class="ident">arr1</span>};
<span class="kw">let</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">Array::linspace</span>(<span class="number">0.</span>, <span class="number">1.</span>, <span class="number">5</span>);
<span class="macro">assert!</span>(<span class="ident">array</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr1</span>(<span class="kw-2">&</span>[<span class="number">0.0</span>, <span class="number">0.25</span>, <span class="number">0.5</span>, <span class="number">0.75</span>, <span class="number">1.0</span>]))</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.range" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.range" class="fnname">range</a>(start: A, end: A, step: A) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="../num_traits/float/trait.Float.html" title="trait num_traits::float::Float">Float</a>, </span></h4><a href="#method.range" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#83-87" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a one-dimensional array from the half-open interval
<code>[start, end)</code> with elements spaced by <code>step</code>. <code>A</code> must be a floating
point type.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">Array</span>, <span class="ident">arr1</span>};
<span class="kw">let</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">Array::range</span>(<span class="number">0.</span>, <span class="number">5.</span>, <span class="number">1.</span>);
<span class="macro">assert!</span>(<span class="ident">array</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr1</span>(<span class="kw-2">&</span>[<span class="number">0.</span>, <span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]))</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, A> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A>, </span></h3><a href="#impl-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#91-107" title="goto source code">[src]</a></div></summary><div class="docblock"><h2 id="constructor-methods-for-two-dimensional-arrays" class="section-header"><a href="#constructor-methods-for-two-dimensional-arrays">Constructor methods for two-dimensional arrays.</a></h2></div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.eye" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.eye" class="fnname">eye</a>(n: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> Self <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a> + <a class="trait" href="../num_traits/identities/trait.One.html" title="trait num_traits::identities::One">One</a>, </span></h4><a href="#method.eye" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#97-106" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an identity matrix of size <code>n</code> (square 2D array).</p>
<p><strong>Panics</strong> if <code>n * n</code> would overflow usize.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, A, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#146-378" title="goto source code">[src]</a></div></summary><div class="docblock"><h2 id="constructor-methods-for-n-dimensional-arrays" class="section-header"><a href="#constructor-methods-for-n-dimensional-arrays">Constructor methods for n-dimensional arrays.</a></h2>
<p>The <code>shape</code> argument can be an integer or a tuple of integers to specify
a static size. For example <code>10</code> makes a length 10 one-dimensional array
(dimension type <code>Ix1</code>) and <code>(5, 6)</code> a 5 × 6 array (dimension type <code>Ix2</code>).</p>
<p>With the trait <code>ShapeBuilder</code> in scope, there is the method <code>.f()</code> to select
column major (“f” order) memory layout instead of the default row major.
For example <code>Array::zeros((5, 6).f())</code> makes a column major 5 × 6 array.</p>
<p>Use <a href="type.IxDyn.html"><code>IxDyn</code></a> for the shape to create an array with dynamic
number of axes.</p>
<p>Finally, the few constructors that take a completely general
<code>Into<StrideShape></code> argument <em>optionally</em> support custom strides, for
example a shape given like <code>(10, 2, 2).strides((1, 10, 20))</code> is valid.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_elem" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_elem" class="fnname">from_elem</a><Sh>(shape: Sh, elem: A) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,<br> Sh: <a class="trait" href="trait.ShapeBuilder.html" title="trait ndarray::ShapeBuilder">ShapeBuilder</a><Dim = D>, </span></h4><a href="#method.from_elem" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#170-181" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with copies of <code>elem</code>, shape <code>shape</code>.</p>
<p><strong>Panics</strong> if the number of elements in <code>shape</code> would overflow usize.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">Array</span>, <span class="ident">arr3</span>, <span class="ident">ShapeBuilder</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array::from_elem</span>((<span class="number">2</span>, <span class="number">2</span>, <span class="number">2</span>), <span class="number">1.</span>);
<span class="macro">assert!</span>(
<span class="ident">a</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[<span class="number">1.</span>, <span class="number">1.</span>],
[<span class="number">1.</span>, <span class="number">1.</span>]],
[[<span class="number">1.</span>, <span class="number">1.</span>],
[<span class="number">1.</span>, <span class="number">1.</span>]]])
);
<span class="macro">assert!</span>(<span class="ident">a</span>.<span class="ident">strides</span>() <span class="op">=</span><span class="op">=</span> <span class="kw-2">&</span>[<span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>]);
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Array::from_elem</span>((<span class="number">2</span>, <span class="number">2</span>, <span class="number">2</span>).<span class="ident">f</span>(), <span class="number">1.</span>);
<span class="macro">assert!</span>(<span class="ident">b</span>.<span class="ident">strides</span>() <span class="op">=</span><span class="op">=</span> <span class="kw-2">&</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>]);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.zeros" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.zeros" class="fnname">zeros</a><Sh>(shape: Sh) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a>,<br> Sh: <a class="trait" href="trait.ShapeBuilder.html" title="trait ndarray::ShapeBuilder">ShapeBuilder</a><Dim = D>, </span></h4><a href="#method.zeros" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#186-191" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with zeros, shape <code>shape</code>.</p>
<p><strong>Panics</strong> if the number of elements in <code>shape</code> would overflow usize.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.default" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.default" class="fnname">default</a><Sh>(shape: Sh) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,<br> Sh: <a class="trait" href="trait.ShapeBuilder.html" title="trait ndarray::ShapeBuilder">ShapeBuilder</a><Dim = D>, </span></h4><a href="#method.default" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#196-204" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with default values, shape <code>shape</code></p>
<p><strong>Panics</strong> if the number of elements in <code>shape</code> would overflow usize.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape_fn" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_shape_fn" class="fnname">from_shape_fn</a><Sh, F>(shape: Sh, f: F) -> Self <span class="where fmt-newline">where<br> Sh: <a class="trait" href="trait.ShapeBuilder.html" title="trait ndarray::ShapeBuilder">ShapeBuilder</a><Dim = D>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(D::<a class="type" href="trait.Dimension.html#associatedtype.Pattern" title="type ndarray::Dimension::Pattern">Pattern</a>) -> A, </span></h4><a href="#method.from_shape_fn" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#212-226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with values created by the function <code>f</code>.</p>
<p><code>f</code> is called with the index of the element to create; the elements are
visited in arbitirary order.</p>
<p><strong>Panics</strong> if the number of elements in <code>shape</code> would overflow usize.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape_vec" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_shape_vec" class="fnname">from_shape_vec</a><Sh>(shape: Sh, v: <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><A>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, <a class="struct" href="struct.ShapeError.html" title="struct ndarray::ShapeError">ShapeError</a>> <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape_vec" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#259-264" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with the given shape from a vector. (No cloning of
elements needed.)</p>
<hr />
<p>For a contiguous c- or f-order shape, the following applies:</p>
<p><strong>Errors</strong> if <code>shape</code> does not correspond to the number of elements in <code>v</code>.</p>
<hr />
<p>For custom strides, the following applies:</p>
<p><strong>Errors</strong> if strides and dimensions can point out of bounds of <code>v</code>.<br>
<strong>Errors</strong> if strides allow multiple indices to point to the same element.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array</span>;
<span class="kw">use</span> <span class="ident">ndarray::ShapeBuilder</span>; <span class="comment">// Needed for .strides() method</span>
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array::from_shape_vec</span>((<span class="number">2</span>, <span class="number">2</span>), <span class="macro">vec!</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]);
<span class="macro">assert!</span>(<span class="ident">a</span>.<span class="ident">is_ok</span>());
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Array::from_shape_vec</span>((<span class="number">2</span>, <span class="number">2</span>).<span class="ident">strides</span>((<span class="number">1</span>, <span class="number">2</span>)),
<span class="macro">vec!</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]).<span class="ident">unwrap</span>();
<span class="macro">assert!</span>(
<span class="ident">b</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">3.</span>],
[<span class="number">2.</span>, <span class="number">4.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape_vec_unchecked" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.from_shape_vec_unchecked" class="fnname">from_shape_vec_unchecked</a><Sh>(shape: Sh, v: <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><A>) -> Self <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape_vec_unchecked" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#284-289" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array from a vector and interpret it according to the
provided dimensions and strides. (No cloning of elements needed.)</p>
<p>Unsafe because dimension and strides are unchecked.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.uninitialized" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.uninitialized" class="fnname">uninitialized</a><Sh>(shape: Sh) -> Self <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,<br> Sh: <a class="trait" href="trait.ShapeBuilder.html" title="trait ndarray::ShapeBuilder">ShapeBuilder</a><Dim = D>, </span></h4><a href="#method.uninitialized" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_constructors.rs.html#367-376" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an array with uninitalized elements, shape <code>shape</code>.</p>
<p><strong>Panics</strong> if the number of elements in <code>shape</code> would overflow usize.</p>
<h3 id="safety" class="section-header"><a href="#safety">Safety</a></h3>
<p>Accessing uninitalized values is undefined behaviour. You must
overwrite <em>all</em> the elements in the array after it is created; for
example using the methods <code>.fill()</code> or <code>.assign()</code>.</p>
<p>The contents of the array is indeterminate before initialization and it
is an error to perform operations that use the previous values. For
example it would not be legal to use <code>a += 1.;</code> on such an array.</p>
<p>This constructor is limited to elements where <code>A: Copy</code> (no destructors)
to avoid users shooting themselves too hard in the foot; it is not
a problem to drop an array created with this method even before elements
are initialized. (Note that constructors <code>from_shape_vec</code> and
<code>from_shape_vec_unchecked</code> allow the user yet more control).</p>
<h3 id="examples" class="section-header"><a href="#examples">Examples</a></h3>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#[<span class="ident">macro_use</span>(<span class="ident">s</span>)]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">ndarray</span>;
<span class="kw">use</span> <span class="ident">ndarray::Array2</span>;
<span class="comment">// Example Task: Let's create a column shifted copy of a in b</span>
<span class="kw">fn</span> <span class="ident">shift_by_two</span>(<span class="ident">a</span>: <span class="kw-2">&</span><span class="ident">Array2</span><span class="op"><</span><span class="ident">f32</span><span class="op">></span>) <span class="op">-</span><span class="op">></span> <span class="ident">Array2</span><span class="op"><</span><span class="ident">f32</span><span class="op">></span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">b</span> <span class="op">=</span> <span class="kw">unsafe</span> { <span class="ident">Array2::uninitialized</span>(<span class="ident">a</span>.<span class="ident">dim</span>()) };
<span class="comment">// two first columns in b are two last in a</span>
<span class="comment">// rest of columns in b are the initial columns in a</span>
<span class="ident">b</span>.<span class="ident">slice_mut</span>(<span class="macro">s!</span>[.., ..<span class="number">2</span>]).<span class="ident">assign</span>(<span class="kw-2">&</span><span class="ident">a</span>.<span class="ident">slice</span>(<span class="macro">s!</span>[.., <span class="op">-</span><span class="number">2</span>..]));
<span class="ident">b</span>.<span class="ident">slice_mut</span>(<span class="macro">s!</span>[.., <span class="number">2</span>..]).<span class="ident">assign</span>(<span class="kw-2">&</span><span class="ident">a</span>.<span class="ident">slice</span>(<span class="macro">s!</span>[.., ..<span class="op">-</span><span class="number">2</span>]));
<span class="comment">// `b` is safe to use with all operations at this point</span>
<span class="ident">b</span>
}
</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-3" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#53-1652" title="goto source code">[src]</a></div></summary><div class="docblock"><h1 id="methods-for-all-array-types" class="section-header"><a href="#methods-for-all-array-types">Methods For All Array Types</a></h1></div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.len" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.len" class="fnname">len</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a></h4><a href="#method.len" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#56-58" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the total number of elements in the array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.len_of" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.len_of" class="fnname">len_of</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a></h4><a href="#method.len_of" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#66-68" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the length of <code>axis</code>.</p>
<p>The axis should be in the range <code>Axis(</code> 0 .. <em>n</em> <code>)</code> where <em>n</em> is the
number of dimensions (axes) of the array.</p>
<p><em><strong>Panics</strong></em> if the axis is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_empty" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.is_empty" class="fnname">is_empty</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.is_empty" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#71-73" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return whether the array has any elements</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ndim" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.ndim" class="fnname">ndim</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a></h4><a href="#method.ndim" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#76-78" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the number of dimensions (axes) in the array</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.dim" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.dim" class="fnname">dim</a>(&self) -> D::<a class="type" href="trait.Dimension.html#associatedtype.Pattern" title="type ndarray::Dimension::Pattern">Pattern</a></h4><a href="#method.dim" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#83-85" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the shape of the array in its “pattern” form,
an integer in the one-dimensional case, tuple in the n-dimensional cases
and so on.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.raw_dim" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.raw_dim" class="fnname">raw_dim</a>(&self) -> D</h4><a href="#method.raw_dim" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#88-90" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the shape of the array as it stored in the array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shape" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.shape" class="fnname">shape</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[</a><a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">]</a></h4><a href="#method.shape" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#93-95" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the shape of the array as a slice.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.strides" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.strides" class="fnname">strides</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[</a><a class="type" href="type.Ixs.html" title="type ndarray::Ixs">Ixs</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">]</a></h4><a href="#method.strides" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#98-104" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the strides of the array as a slice</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.view" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.view" class="fnname">view</a>(&self) -> <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'_, A, D></h4><a href="#method.view" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#107-112" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a read-only view of the array</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.view_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.view_mut" class="fnname">view_mut</a>(&mut self) -> <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'_, A, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.view_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#115-122" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a read-write view of the array</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_owned" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.to_owned" class="fnname">to_owned</a>(&self) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.to_owned" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#125-137" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an uniquely owned copy of the array</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_shared" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.to_shared" class="fnname">to_shared</a>(&self) -> <a class="type" href="type.RcArray.html" title="type ndarray::RcArray">RcArray</a><A, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.to_shared" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#140-145" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a shared ownership (copy on write) array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_owned" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_owned" class="fnname">into_owned</a>(self) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a>, </span></h4><a href="#method.into_owned" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#149-154" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Turn the array into a uniquely owned array, cloning the array elements
to unshare them if necessary.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_shared" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_shared" class="fnname">into_shared</a>(self) -> <a class="type" href="type.RcArray.html" title="type ndarray::RcArray">RcArray</a><A, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a>, </span></h4><a href="#method.into_shared" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#158-168" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Turn the array into a shared ownership (copy on write) array,
without any copying.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.iter" class="fnname">iter</a>(&self) -> <a class="struct" href="iter/struct.Iter.html" title="struct ndarray::iter::Iter">Iter</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.Iter.html" title="struct ndarray::iter::Iter">Iter</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.Iter.html" title="struct ndarray::iter::Iter">Iter</a><'a, A, D></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A;</span></code></span></div></span></span></h4><a href="#method.iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#176-179" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator of references to the elements of the array.</p>
<p>Elements are visited in the <em>logical order</em> of the array, which
is where the rightmost index is varying the fastest.</p>
<p>Iterator element type is <code>&A</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.iter_mut" class="fnname">iter_mut</a>(&mut self) -> <a class="struct" href="iter/struct.IterMut.html" title="struct ndarray::iter::IterMut">IterMut</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.IterMut.html" title="struct ndarray::iter::IterMut">IterMut</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.IterMut.html" title="struct ndarray::iter::IterMut">IterMut</a><'a, A, D></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>A;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.iter_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#187-191" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator of mutable references to the elements of the array.</p>
<p>Elements are visited in the <em>logical order</em> of the array, which
is where the rightmost index is varying the fastest.</p>
<p>Iterator element type is <code>&mut A</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.indexed_iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.indexed_iter" class="fnname">indexed_iter</a>(&self) -> <a class="struct" href="iter/struct.IndexedIter.html" title="struct ndarray::iter::IndexedIter">IndexedIter</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.IndexedIter.html" title="struct ndarray::iter::IndexedIter">IndexedIter</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.IndexedIter.html" title="struct ndarray::iter::IndexedIter">IndexedIter</a><'a, A, D></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">(</a>D::<a class="type" href="trait.Dimension.html#associatedtype.Pattern" title="type ndarray::Dimension::Pattern">Pattern</a>, <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">)</a>;</span></code></span></div></span></span></h4><a href="#method.indexed_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#201-203" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator of indexes and references to the elements of the array.</p>
<p>Elements are visited in the <em>logical order</em> of the array, which
is where the rightmost index is varying the fastest.</p>
<p>Iterator element type is <code>(D::Pattern, &A)</code>.</p>
<p>See also <a href="struct.Zip.html"><code>Zip::indexed</code></a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.indexed_iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.indexed_iter_mut" class="fnname">indexed_iter_mut</a>(&mut self) -> <a class="struct" href="iter/struct.IndexedIterMut.html" title="struct ndarray::iter::IndexedIterMut">IndexedIterMut</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.IndexedIterMut.html" title="struct ndarray::iter::IndexedIterMut">IndexedIterMut</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.IndexedIterMut.html" title="struct ndarray::iter::IndexedIterMut">IndexedIterMut</a><'a, A, D></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">(</a>D::<a class="type" href="trait.Dimension.html#associatedtype.Pattern" title="type ndarray::Dimension::Pattern">Pattern</a>, <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>A<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">)</a>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.indexed_iter_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#211-215" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator of indexes and mutable references to the elements of the array.</p>
<p>Elements are visited in the <em>logical order</em> of the array, which
is where the rightmost index is varying the fastest.</p>
<p>Iterator element type is <code>(D::Pattern, &mut A)</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.slice" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.slice" class="fnname">slice</a>(&self, indexes: &D::<a class="type" href="trait.Dimension.html#associatedtype.SliceArg" title="type ndarray::Dimension::SliceArg">SliceArg</a>) -> <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'_, A, D></h4><a href="#method.slice" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#227-231" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a sliced array.</p>
<p>See <a href="#slicing"><em>Slicing</em></a> for full documentation.
See also <a href="trait.Dimension.html#associatedtype.SliceArg"><code>D::SliceArg</code></a>.</p>
<p><strong>Panics</strong> if an index is out of bounds or stride is zero.<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>indexes</code> does not match the number of array axes.)</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.slice_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.slice_mut" class="fnname">slice_mut</a>(&mut self, indexes: &D::<a class="type" href="trait.Dimension.html#associatedtype.SliceArg" title="type ndarray::Dimension::SliceArg">SliceArg</a>) -> <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'_, A, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.slice_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#241-247" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a sliced read-write view of the array.</p>
<p>See also <a href="trait.Dimension.html#associatedtype.SliceArg"><code>D::SliceArg</code></a>.</p>
<p><strong>Panics</strong> if an index is out of bounds or stride is zero.<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>indexes</code> does not match the number of array axes.)</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.islice" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.islice" class="fnname">islice</a>(&mut self, indexes: &D::<a class="type" href="trait.Dimension.html#associatedtype.SliceArg" title="type ndarray::Dimension::SliceArg">SliceArg</a>)</h4><a href="#method.islice" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#257-263" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Slice the array’s view in place.</p>
<p>See also <a href="trait.Dimension.html#associatedtype.SliceArg"><code>D::SliceArg</code></a>.</p>
<p><strong>Panics</strong> if an index is out of bounds or stride is zero.<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>indexes</code> does not match the number of array axes.)</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.get" class="fnname">get</a><I>(&self, index: I) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>A> <span class="where fmt-newline">where<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.get" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#285-291" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a reference to the element at <code>index</code>, or return <code>None</code>
if the index is out of bounds.</p>
<p>Arrays also support indexing syntax: <code>array[index]</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">get</span>((<span class="number">0</span>, <span class="number">1</span>)) <span class="op">=</span><span class="op">=</span> <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">2.</span>) <span class="op">&&</span>
<span class="ident">a</span>.<span class="ident">get</span>((<span class="number">0</span>, <span class="number">2</span>)) <span class="op">=</span><span class="op">=</span> <span class="prelude-val">None</span> <span class="op">&&</span>
<span class="ident">a</span>[(<span class="number">0</span>, <span class="number">1</span>)] <span class="op">=</span><span class="op">=</span> <span class="number">2.</span> <span class="op">&&</span>
<span class="ident">a</span>[[<span class="number">0</span>, <span class="number">1</span>]] <span class="op">=</span><span class="op">=</span> <span class="number">2.</span>
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.get_mut" class="fnname">get_mut</a><I>(&mut self, index: I) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>A> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.get_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#303-310" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a mutable reference to the element at <code>index</code>, or return <code>None</code>
if the index is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.uget" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.uget" class="fnname">uget</a><I>(&self, index: I) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>A <span class="where fmt-newline">where<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.uget" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#329-335" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <em>unchecked</em> array indexing.</p>
<p>Return a reference to the element at <code>index</code>.</p>
<p><strong>Note:</strong> only unchecked for non-debug builds of ndarray.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.uget_mut" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.uget_mut" class="fnname">uget_mut</a><I>(&mut self, index: I) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>A <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.uget_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#344-352" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <em>unchecked</em> array indexing.</p>
<p>Return a mutable reference to the element at <code>index</code>.</p>
<p><strong>Note:</strong> Only unchecked for non-debug builds of ndarray.<br>
<strong>Note:</strong> (For <code>RcArray</code>) The array must be uniquely held when mutating it.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.swap" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.swap" class="fnname">swap</a><I>(&mut self, index1: I, index2: I) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.swap" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#359-368" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Swap elements at indices <code>index1</code> and <code>index2</code>.</p>
<p>Indices may be equal.</p>
<p><em><strong>Panics</strong></em> if an index is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.uswap" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.uswap" class="fnname">uswap</a><I>(&mut self, index1: I, index2: I) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>, </span></h4><a href="#method.uswap" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#376-386" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Swap elements <em>unchecked</em> at indices <code>index1</code> and <code>index2</code>.</p>
<p>Indices may be equal.</p>
<p><strong>Note:</strong> only unchecked for non-debug builds of ndarray.<br>
<strong>Note:</strong> (For <code>RcArray</code>) The array must be uniquely held.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.subview" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.subview" class="fnname">subview</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.subview" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#418-422" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Along <code>axis</code>, select the subview <code>index</code> and return a
view with that axis removed.</p>
<p>See <a href="#subviews"><em>Subviews</em></a> for full documentation.</p>
<p><strong>Panics</strong> if <code>axis</code> or <code>index</code> is out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr2</span>, <span class="ident">ArrayView</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span> ], <span class="comment">// ... axis 0, row 0</span>
[<span class="number">3.</span>, <span class="number">4.</span> ], <span class="comment">// --- axis 0, row 1</span>
[<span class="number">5.</span>, <span class="number">6.</span> ]]); <span class="comment">// ... axis 0, row 2</span>
<span class="comment">// . \</span>
<span class="comment">// . axis 1, column 1</span>
<span class="comment">// axis 1, column 0</span>
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">subview</span>(<span class="ident">Axis</span>(<span class="number">0</span>), <span class="number">1</span>) <span class="op">=</span><span class="op">=</span> <span class="ident">ArrayView::from</span>(<span class="kw-2">&</span>[<span class="number">3.</span>, <span class="number">4.</span>]) <span class="op">&&</span>
<span class="ident">a</span>.<span class="ident">subview</span>(<span class="ident">Axis</span>(<span class="number">1</span>), <span class="number">1</span>) <span class="op">=</span><span class="op">=</span> <span class="ident">ArrayView::from</span>(<span class="kw-2">&</span>[<span class="number">2.</span>, <span class="number">4.</span>, <span class="number">6.</span>])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.subview_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.subview_mut" class="fnname">subview_mut</a>(<br> &mut self, <br> axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, <br> index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a><br>) -> <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.subview_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#448-454" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Along <code>axis</code>, select the subview <code>index</code> and return a read-write view
with the axis removed.</p>
<p><strong>Panics</strong> if <code>axis</code> or <code>index</code> is out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr2</span>, <span class="ident">aview2</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span> ],
[<span class="number">3.</span>, <span class="number">4.</span> ]]);
<span class="comment">// . \</span>
<span class="comment">// . axis 1, column 1</span>
<span class="comment">// axis 1, column 0</span>
{
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">column1</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">subview_mut</span>(<span class="ident">Axis</span>(<span class="number">1</span>), <span class="number">1</span>);
<span class="ident">column1</span> <span class="op">+</span><span class="op">=</span> <span class="number">10.</span>;
}
<span class="macro">assert!</span>(
<span class="ident">a</span> <span class="op">=</span><span class="op">=</span> <span class="ident">aview2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">12.</span>],
[<span class="number">3.</span>, <span class="number">14.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.isubview" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.isubview" class="fnname">isubview</a>(&mut self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>)</h4><a href="#method.isubview" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#460-463" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Collapse dimension <code>axis</code> into length one,
and select the subview of <code>index</code> along that axis.</p>
<p><strong>Panics</strong> if <code>index</code> is past the length of the axis.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_subview" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_subview" class="fnname">into_subview</a>(self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.into_subview" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#469-474" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Along <code>axis</code>, select the subview <code>index</code> and return <code>self</code>
with that axis removed.</p>
<p>See <a href="#method.subview"><code>.subview()</code></a> and <a href="#subviews"><em>Subviews</em></a> for full documentation.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.select" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.select" class="fnname">select</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, indices: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[</a><a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">]</a>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.select" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#497-514" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Along <code>axis</code>, select arbitrary subviews corresponding to <code>indices</code>
and and copy them into a new array.</p>
<p><strong>Panics</strong> if <code>axis</code> or an element of <code>indices</code> is out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr2</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">0.</span>, <span class="number">1.</span>],
[<span class="number">2.</span>, <span class="number">3.</span>],
[<span class="number">4.</span>, <span class="number">5.</span>],
[<span class="number">6.</span>, <span class="number">7.</span>],
[<span class="number">8.</span>, <span class="number">9.</span>]]);
<span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">select</span>(<span class="ident">Axis</span>(<span class="number">0</span>), <span class="kw-2">&</span>[<span class="number">0</span>, <span class="number">4</span>, <span class="number">3</span>]);
<span class="macro">assert!</span>(
<span class="ident">r</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">0.</span>, <span class="number">1.</span>],
[<span class="number">8.</span>, <span class="number">9.</span>],
[<span class="number">6.</span>, <span class="number">7.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.genrows" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.genrows" class="fnname">genrows</a>(&self) -> <a class="struct" href="iter/struct.Lanes.html" title="struct ndarray::iter::Lanes">Lanes</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>></h4><a href="#method.genrows" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#542-546" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over the <em>generalized</em>
rows of the array. For a 2D array these are the regular rows.</p>
<p>This is equivalent to <code>.lanes(Axis(n - 1))</code> where <em>n</em> is <code>self.ndim()</code>.</p>
<p>For an array of dimensions <em>a</em> × <em>b</em> × <em>c</em> × … × <em>l</em> × <em>m</em>
it has <em>a</em> × <em>b</em> × <em>c</em> × … × <em>l</em> rows each of length <em>m</em>.</p>
<p>For example, in a 2 × 2 × 3 array, each row is 3 elements long
and there are 2 × 2 = 4 rows in total.</p>
<p>Iterator element is <code>ArrayView1<A></code> (1D array view).</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr3</span>, <span class="ident">Axis</span>, <span class="ident">arr1</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>], <span class="comment">// -- row 0, 0</span>
[ <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]], <span class="comment">// -- row 0, 1</span>
[[ <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>], <span class="comment">// -- row 1, 0</span>
[ <span class="number">9</span>, <span class="number">10</span>, <span class="number">11</span>]]]); <span class="comment">// -- row 1, 1</span>
<span class="comment">// `genrows` will yield the four generalized rows of the array.</span>
<span class="kw">for</span> <span class="ident">row</span> <span class="kw">in</span> <span class="ident">a</span>.<span class="ident">genrows</span>() {
<span class="comment">/* loop body */</span>
}</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.genrows_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.genrows_mut" class="fnname">genrows_mut</a>(&mut self) -> <a class="struct" href="iter/struct.LanesMut.html" title="struct ndarray::iter::LanesMut">LanesMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.genrows_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#552-558" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over the <em>generalized</em>
rows of the array and yields mutable array views.</p>
<p>Iterator element is <code>ArrayView1<A></code> (1D read-write array view).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.gencolumns" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.gencolumns" class="fnname">gencolumns</a>(&self) -> <a class="struct" href="iter/struct.Lanes.html" title="struct ndarray::iter::Lanes">Lanes</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>></h4><a href="#method.gencolumns" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#586-588" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over the <em>generalized</em>
columns of the array. For a 2D array these are the regular columns.</p>
<p>This is equivalent to <code>.lanes(Axis(0))</code>.</p>
<p>For an array of dimensions <em>a</em> × <em>b</em> × <em>c</em> × … × <em>l</em> × <em>m</em>
it has <em>b</em> × <em>c</em> × … × <em>l</em> × <em>m</em> columns each of length <em>a</em>.</p>
<p>For example, in a 2 × 2 × 3 array, each column is 2 elements long
and there are 2 × 3 = 6 columns in total.</p>
<p>Iterator element is <code>ArrayView1<A></code> (1D array view).</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr3</span>, <span class="ident">Axis</span>, <span class="ident">arr1</span>};
<span class="comment">// The generalized columns of a 3D array:</span>
<span class="comment">// are directed along the 0th axis: 0 and 6, 1 and 7 and so on...</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>], [ <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]],
[[ <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>], [ <span class="number">9</span>, <span class="number">10</span>, <span class="number">11</span>]]]);
<span class="comment">// Here `gencolumns` will yield the six generalized columns of the array.</span>
<span class="kw">for</span> <span class="ident">row</span> <span class="kw">in</span> <span class="ident">a</span>.<span class="ident">gencolumns</span>() {
<span class="comment">/* loop body */</span>
}</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.gencolumns_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.gencolumns_mut" class="fnname">gencolumns_mut</a>(&mut self) -> <a class="struct" href="iter/struct.LanesMut.html" title="struct ndarray::iter::LanesMut">LanesMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.gencolumns_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#594-598" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over the <em>generalized</em>
columns of the array and yields mutable array views.</p>
<p>Iterator element is <code>ArrayView1<A></code> (1D read-write array view).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.lanes" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.lanes" class="fnname">lanes</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="iter/struct.Lanes.html" title="struct ndarray::iter::Lanes">Lanes</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>></h4><a href="#method.lanes" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#628-630" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over all 1D lanes
pointing in the direction of <code>axis</code>.</p>
<p>When the pointing in the direction of the first axis, they are <em>columns</em>,
in the direction of the last axis <em>rows</em>; in general they are all
<em>lanes</em> and are one dimensional.</p>
<p>Iterator element is <code>ArrayView1<A></code> (1D array view).</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr3</span>, <span class="ident">aview1</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>],
[ <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]],
[[ <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>],
[ <span class="number">9</span>, <span class="number">10</span>, <span class="number">11</span>]]]);
<span class="kw">let</span> <span class="ident">inner0</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">lanes</span>(<span class="ident">Axis</span>(<span class="number">0</span>));
<span class="kw">let</span> <span class="ident">inner1</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">lanes</span>(<span class="ident">Axis</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">inner2</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">lanes</span>(<span class="ident">Axis</span>(<span class="number">2</span>));
<span class="comment">// The first lane for axis 0 is [0, 6]</span>
<span class="macro">assert_eq!</span>(<span class="ident">inner0</span>.<span class="ident">into_iter</span>().<span class="ident">next</span>().<span class="ident">unwrap</span>(), <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">0</span>, <span class="number">6</span>]));
<span class="comment">// The first lane for axis 1 is [0, 3]</span>
<span class="macro">assert_eq!</span>(<span class="ident">inner1</span>.<span class="ident">into_iter</span>().<span class="ident">next</span>().<span class="ident">unwrap</span>(), <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">0</span>, <span class="number">3</span>]));
<span class="comment">// The first lane for axis 2 is [0, 1, 2]</span>
<span class="macro">assert_eq!</span>(<span class="ident">inner2</span>.<span class="ident">into_iter</span>().<span class="ident">next</span>().<span class="ident">unwrap</span>(), <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>]));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.lanes_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.lanes_mut" class="fnname">lanes_mut</a>(&mut self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="iter/struct.LanesMut.html" title="struct ndarray::iter::LanesMut">LanesMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.lanes_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#636-640" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a producer and iterable that traverses over all 1D lanes
pointing in the direction of <code>axis</code>.</p>
<p>Iterator element is <code>ArrayViewMut1<A></code> (1D read-write array view).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.outer_iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.outer_iter" class="fnname">outer_iter</a>(&self) -> <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'a, A, D>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.outer_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#650-654" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over the outermost dimension
and yields each subview.</p>
<p>This is equivalent to <code>.axis_iter(Axis(0))</code>.</p>
<p>Iterator element is <code>ArrayView<A, D::Smaller></code> (read-only array view).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.outer_iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.outer_iter_mut" class="fnname">outer_iter_mut</a>(&mut self) -> <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'a, A, D>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.outer_iter_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#663-668" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over the outermost dimension
and yields each subview.</p>
<p>This is equivalent to <code>.axis_iter_mut(Axis(0))</code>.</p>
<p>Iterator element is <code>ArrayViewMut<A, D::Smaller></code> (read-write array view).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.axis_iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.axis_iter" class="fnname">axis_iter</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisIter.html" title="struct ndarray::iter::AxisIter">AxisIter</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'a, A, D>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.axis_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#685-689" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over <code>axis</code>
and yields each subview along it.</p>
<p>For example, in a 3 × 4 × 5 array, with <code>axis</code> equal to <code>Axis(2)</code>,
the iterator element
is a 3 × 4 subview (and there are 5 in total), as shown
in the picture below.</p>
<p>Iterator element is <code>ArrayView<A, D::Smaller></code> (read-only array view).</p>
<p>See <a href="#subviews"><em>Subviews</em></a> for full documentation.</p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
<img src="https://bluss.github.io/ndarray/images/axis_iter_3_4_5.svg" height="250px"></div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.axis_iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.axis_iter_mut" class="fnname">axis_iter_mut</a>(&mut self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'_, A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisIterMut.html" title="struct ndarray::iter::AxisIterMut">AxisIterMut</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'a, A, D>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.axis_iter_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#699-704" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over <code>axis</code>
and yields each mutable subview along it.</p>
<p>Iterator element is <code>ArrayViewMut<A, D::Smaller></code>
(read-write array view).</p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.axis_chunks_iter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.axis_chunks_iter" class="fnname">axis_chunks_iter</a>(<br> &self, <br> axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, <br> size: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><br>) -> <a class="struct" href="iter/struct.AxisChunksIter.html" title="struct ndarray::iter::AxisChunksIter">AxisChunksIter</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisChunksIter.html" title="struct ndarray::iter::AxisChunksIter">AxisChunksIter</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisChunksIter.html" title="struct ndarray::iter::AxisChunksIter">AxisChunksIter</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'a, A, D>;</span></code></span></div></span></span></h4><a href="#method.axis_chunks_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#733-735" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over <code>axis</code> by chunks of <code>size</code>,
yielding non-overlapping views along that axis.</p>
<p>Iterator element is <code>ArrayView<A, D></code></p>
<p>The last view may have less elements if <code>size</code> does not divide
the axis’ dimension.</p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array</span>;
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr3</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array::from_iter</span>(<span class="number">0</span>..<span class="number">28</span>).<span class="ident">into_shape</span>((<span class="number">2</span>, <span class="number">7</span>, <span class="number">2</span>)).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">iter</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">axis_chunks_iter</span>(<span class="ident">Axis</span>(<span class="number">1</span>), <span class="number">2</span>);
<span class="comment">// first iteration yields a 2 × 2 × 2 view</span>
<span class="macro">assert_eq!</span>(<span class="ident">iter</span>.<span class="ident">next</span>().<span class="ident">unwrap</span>(),
<span class="ident">arr3</span>(<span class="kw-2">&</span>[[[ <span class="number">0</span>, <span class="number">1</span>], [ <span class="number">2</span>, <span class="number">3</span>]],
[[<span class="number">14</span>, <span class="number">15</span>], [<span class="number">16</span>, <span class="number">17</span>]]]));
<span class="comment">// however the last element is a 2 × 1 × 2 view since 7 % 2 == 1</span>
<span class="macro">assert_eq!</span>(<span class="ident">iter</span>.<span class="ident">next_back</span>().<span class="ident">unwrap</span>(), <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[<span class="number">12</span>, <span class="number">13</span>]],
[[<span class="number">26</span>, <span class="number">27</span>]]]));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.axis_chunks_iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.axis_chunks_iter_mut" class="fnname">axis_chunks_iter_mut</a>(<br> &mut self, <br> axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, <br> size: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><br>) -> <a class="struct" href="iter/struct.AxisChunksIterMut.html" title="struct ndarray::iter::AxisChunksIterMut">AxisChunksIterMut</a><'_, A, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.AxisChunksIterMut.html" title="struct ndarray::iter::AxisChunksIterMut">AxisChunksIterMut</a><'a, A, D></div><code class="content"><span class="where fmt-newline">impl<'a, A, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.AxisChunksIterMut.html" title="struct ndarray::iter::AxisChunksIterMut">AxisChunksIterMut</a><'a, A, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'a, A, D>;</span></code></span></div></span></span> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.axis_chunks_iter_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#743-748" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator that traverses over <code>axis</code> by chunks of <code>size</code>,
yielding non-overlapping read-write views along that axis.</p>
<p>Iterator element is <code>ArrayViewMut<A, D></code></p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.exact_chunks" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.exact_chunks" class="fnname">exact_chunks</a><E>(&self, chunk_size: E) -> <a class="struct" href="iter/struct.ExactChunks.html" title="struct ndarray::iter::ExactChunks">ExactChunks</a><'_, A, D> <span class="where fmt-newline">where<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a><Dim = D>, </span></h4><a href="#method.exact_chunks" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#761-765" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an exact chunks producer (and iterable).</p>
<p>It produces the whole chunks of a given n-dimensional chunk size,
skipping the remainder along each dimension that doesn’t fit evenly.</p>
<p>The produced element is a <code>ArrayView<A, D></code> with exactly the dimension
<code>chunk_size</code>.</p>
<p><strong>Panics</strong> if any dimension of <code>chunk_size</code> is zero<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>chunk_size</code> does not match the
number of array axes.)</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.exact_chunks_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.exact_chunks_mut" class="fnname">exact_chunks_mut</a><E>(&mut self, chunk_size: E) -> <a class="struct" href="iter/struct.ExactChunksMut.html" title="struct ndarray::iter::ExactChunksMut">ExactChunksMut</a><'_, A, D> <span class="where fmt-newline">where<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a><Dim = D>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.exact_chunks_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#807-812" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an exact chunks producer (and iterable).</p>
<p>It produces the whole chunks of a given n-dimensional chunk size,
skipping the remainder along each dimension that doesn’t fit evenly.</p>
<p>The produced element is a <code>ArrayViewMut<A, D></code> with exactly
the dimension <code>chunk_size</code>.</p>
<p><strong>Panics</strong> if any dimension of <code>chunk_size</code> is zero<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>chunk_size</code> does not match the
number of array axes.)</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array</span>;
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array::zeros</span>((<span class="number">6</span>, <span class="number">7</span>));
<span class="comment">// Fill each 2 × 2 chunk with the index of where it appeared in iteration</span>
<span class="kw">for</span> (<span class="ident">i</span>, <span class="kw-2">mut</span> <span class="ident">chunk</span>) <span class="kw">in</span> <span class="ident">a</span>.<span class="ident">exact_chunks_mut</span>((<span class="number">2</span>, <span class="number">2</span>)).<span class="ident">into_iter</span>().<span class="ident">enumerate</span>() {
<span class="ident">chunk</span>.<span class="ident">fill</span>(<span class="ident">i</span>);
}
<span class="comment">// The resulting array is:</span>
<span class="macro">assert_eq!</span>(
<span class="ident">a</span>,
<span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">0</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">0</span>],
[<span class="number">0</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">0</span>],
[<span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">5</span>, <span class="number">0</span>],
[<span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">5</span>, <span class="number">0</span>],
[<span class="number">6</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">8</span>, <span class="number">0</span>],
[<span class="number">6</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">8</span>, <span class="number">0</span>]]));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.windows" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.windows" class="fnname">windows</a><E>(&self, window_size: E) -> <a class="struct" href="iter/struct.Windows.html" title="struct ndarray::iter::Windows">Windows</a><'_, A, D> <span class="where fmt-newline">where<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a><Dim = D>, </span></h4><a href="#method.windows" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#837-841" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a window producer and iterable.</p>
<p>The windows are all distinct overlapping views of size <code>window_size</code>
that fit into the array’s shape.</p>
<p>Will yield over no elements if window size is larger
than the actual array size of any dimension.</p>
<p>The produced element is an <code>ArrayView<A, D></code> with exactly the dimension
<code>window_size</code>.</p>
<p><strong>Panics</strong> if any dimension of <code>window_size</code> is zero.<br>
(<strong>Panics</strong> if <code>D</code> is <code>IxDyn</code> and <code>window_size</code> does not match the
number of array axes.)</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.diag" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.diag" class="fnname">diag</a>(&self) -> <a class="type" href="type.ArrayView1.html" title="type ndarray::ArrayView1">ArrayView1</a><'_, A></h4><a href="#method.diag" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#857-859" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an view of the diagonal elements of the array.</p>
<p>The diagonal is simply the sequence indexed by <em>(0, 0, .., 0)</em>,
<em>(1, 1, …, 1)</em> etc as long as all axes have elements.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.diag_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.diag_mut" class="fnname">diag_mut</a>(&mut self) -> <a class="type" href="type.ArrayViewMut1.html" title="type ndarray::ArrayViewMut1">ArrayViewMut1</a><'_, A> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.diag_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#862-866" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a read-write view over the diagonal elements of the array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_diag" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_diag" class="fnname">into_diag</a>(self) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>></h4><a href="#method.into_diag" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#869-877" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the diagonal as a one-dimensional array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_standard_layout" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.is_standard_layout" class="fnname">is_standard_layout</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.is_standard_layout" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#895-911" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return <code>true</code> if the array data is laid out in contiguous “C order” in
memory (where the last index is the most rapidly varying).</p>
<p>Return <code>false</code> otherwise, i.e the array is possibly not
contiguous in memory, it has custom strides, etc.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ptr" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_ptr" class="fnname">as_ptr</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.pointer.html">*const A</a></h4><a href="#method.as_ptr" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#927-929" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a pointer to the first element in the array.</p>
<p>Raw access to array elements needs to follow the strided indexing
scheme: an element at multi-index <em>I</em> in an array with strides <em>S</em> is
located at offset</p>
<p><em>Σ<sub>0 ≤ k < d</sub> I<sub>k</sub> × S<sub>k</sub></em></p>
<p>where <em>d</em> is <code>self.ndim()</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_mut_ptr" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_mut_ptr" class="fnname">as_mut_ptr</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.pointer.html">*mut A</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.as_mut_ptr" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#933-938" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a mutable pointer to the first element in the array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_slice" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_slice" class="fnname">as_slice</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[A]</a>></h4><a href="#method.as_slice" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#945-953" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice, if it is contiguous and in standard order.
Return <code>None</code> otherwise.</p>
<p>If this function returns <code>Some(_)</code>, then the element order in the slice
corresponds to the logical order of the array’s elements.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_slice_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_slice_mut" class="fnname">as_slice_mut</a>(&mut self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&mut [A]</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.as_slice_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#957-968" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice, if it is contiguous and in standard order.
Return <code>None</code> otherwise.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_slice_memory_order" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_slice_memory_order" class="fnname">as_slice_memory_order</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[A]</a>></h4><a href="#method.as_slice_memory_order" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#977-985" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice if it is contiguous,
return <code>None</code> otherwise.</p>
<p>If this function returns <code>Some(_)</code>, then the elements in the slice
have whatever order the elements have in memory.</p>
<p>Implementation notes: Does not yet support negatively strided arrays.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_slice_memory_order_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_slice_memory_order_mut" class="fnname">as_slice_memory_order_mut</a>(&mut self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&mut [A]</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.as_slice_memory_order_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#989-1000" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice if it is contiguous,
return <code>None</code> otherwise.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_shape" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_shape" class="fnname">into_shape</a><E>(self, shape: E) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, E::<a class="type" href="trait.IntoDimension.html#associatedtype.Dim" title="type ndarray::IntoDimension::Dim">Dim</a>>, <a class="struct" href="struct.ShapeError.html" title="struct ndarray::ShapeError">ShapeError</a>> <span class="where fmt-newline">where<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a>, </span></h4><a href="#method.into_shape" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1018-1043" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Transform the array into <code>shape</code>; any shape with the same number of
elements is accepted, but the source array or view must be
contiguous, otherwise we cannot rearrange the dimension.</p>
<p><strong>Errors</strong> if the shapes don’t have the same number of elements.<br>
<strong>Errors</strong> if the input array is not c- or f-contiguous.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">aview1</span>, <span class="ident">aview2</span>};
<span class="macro">assert!</span>(
<span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]).<span class="ident">into_shape</span>((<span class="number">2</span>, <span class="number">2</span>)).<span class="ident">unwrap</span>()
<span class="op">=</span><span class="op">=</span> <span class="ident">aview2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.reshape" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.reshape" class="fnname">reshape</a><E>(&self, shape: E) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, E::<a class="type" href="trait.IntoDimension.html#associatedtype.Dim" title="type ndarray::IntoDimension::Dim">Dim</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataShared.html" title="trait ndarray::DataShared">DataShared</a> + <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a>,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a>, </span></h4><a href="#method.reshape" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1065-1091" title="goto source code">[src]</a></div></summary><div class="docblock"><p><em>Note: Reshape is for <code>RcArray</code> only. Use <code>.into_shape()</code> for
other arrays and array views.</em></p>
<p>Transform the array into <code>shape</code>; any shape with the same number of
elements is accepted.</p>
<p>May clone all elements if needed to arrange elements in standard
layout (and break sharing).</p>
<p><strong>Panics</strong> if shapes are incompatible.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">rcarr1</span>, <span class="ident">rcarr2</span>};
<span class="macro">assert!</span>(
<span class="ident">rcarr1</span>(<span class="kw-2">&</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">4.</span>]).<span class="ident">reshape</span>((<span class="number">2</span>, <span class="number">2</span>))
<span class="op">=</span><span class="op">=</span> <span class="ident">rcarr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_dyn" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_dyn" class="fnname">into_dyn</a>(self) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.IxDyn.html" title="type ndarray::IxDyn">IxDyn</a>></h4><a href="#method.into_dyn" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1102-1109" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Convert any array or array view to a dynamic dimensional array or
array view (respectively).</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">arr2</span>, <span class="ident">ArrayD</span>};
<span class="kw">let</span> <span class="ident">array</span>: <span class="ident">ArrayD</span><span class="op"><</span><span class="ident">i32</span><span class="op">></span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1</span>, <span class="number">2</span>],
[<span class="number">3</span>, <span class="number">4</span>]]).<span class="ident">into_dyn</span>();</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_dimensionality" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_dimensionality" class="fnname">into_dimensionality</a><D2>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D2>, <a class="struct" href="struct.ShapeError.html" title="struct ndarray::ShapeError">ShapeError</a>> <span class="where fmt-newline">where<br> D2: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h4><a href="#method.into_dimensionality" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1124-1138" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Convert an array or array view to another with the same type, but
different dimensionality type. Errors if the dimensions don’t agree.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">ArrayD</span>, <span class="ident">Ix2</span>, <span class="ident">IxDyn</span>};
<span class="comment">// Create a dynamic dimensionality array and convert it to an Array2</span>
<span class="comment">// (Ix2 dimension type).</span>
<span class="kw">let</span> <span class="ident">array</span> <span class="op">=</span> <span class="ident">ArrayD</span>::<span class="op"><</span><span class="ident">f64</span><span class="op">></span><span class="ident">::zeros</span>(<span class="ident">IxDyn</span>(<span class="kw-2">&</span>[<span class="number">10</span>, <span class="number">10</span>]));
<span class="macro">assert!</span>(<span class="ident">array</span>.<span class="ident">into_dimensionality</span>::<span class="op"><</span><span class="ident">Ix2</span><span class="op">></span>().<span class="ident">is_ok</span>());</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.broadcast" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.broadcast" class="fnname">broadcast</a><E>(&self, dim: E) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'_, A, E::<a class="type" href="trait.IntoDimension.html#associatedtype.Dim" title="type ndarray::IntoDimension::Dim">Dim</a>>> <span class="where fmt-newline">where<br> E: <a class="trait" href="trait.IntoDimension.html" title="trait ndarray::IntoDimension">IntoDimension</a>, </span></h4><a href="#method.broadcast" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1169-1221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Act like a larger size and/or shape array by <em>broadcasting</em>
into a larger shape, if possible.</p>
<p>Return <code>None</code> if shapes can not be broadcast together.</p>
<p><em><strong>Background</strong></em></p>
<ul>
<li>Two axes are compatible if they are equal, or one of them is 1.</li>
<li>In this instance, only the axes of the smaller side (self) can be 1.</li>
</ul>
<p>Compare axes beginning with the <em>last</em> axis of each shape.</p>
<p>For example (1, 2, 4) can be broadcast into (7, 6, 2, 4)
because its axes are either equal or 1 (or missing);
while (2, 2) can <em>not</em> be broadcast into (2, 4).</p>
<p>The implementation creates a view with strides set to zero for the
axes that are to be repeated.</p>
<p>The broadcasting documentation for Numpy has more information.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">aview1</span>, <span class="ident">aview2</span>};
<span class="macro">assert!</span>(
<span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">1.</span>, <span class="number">0.</span>]).<span class="ident">broadcast</span>((<span class="number">10</span>, <span class="number">2</span>)).<span class="ident">unwrap</span>()
<span class="op">=</span><span class="op">=</span> <span class="ident">aview2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">0.</span>]; <span class="number">10</span>])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.swap_axes" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.swap_axes" class="fnname">swap_axes</a>(&mut self, ax: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a>, bx: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a>)</h4><a href="#method.swap_axes" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1239-1242" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Swap axes <code>ax</code> and <code>bx</code>.</p>
<p>This does not move any data, it just adjusts the array’s dimensions
and strides.</p>
<p><strong>Panics</strong> if the axes are out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>]]);
<span class="ident">a</span>.<span class="ident">swap_axes</span>(<span class="number">0</span>, <span class="number">1</span>);
<span class="macro">assert!</span>(
<span class="ident">a</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>], [<span class="number">2.</span>], [<span class="number">3.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.reversed_axes" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.reversed_axes" class="fnname">reversed_axes</a>(self) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.reversed_axes" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1248-1252" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Transpose the array by reversing axes.</p>
<p>Transposition reverses the order of the axes (dimensions and strides)
while retaining the same data.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.t" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.t" class="fnname">t</a>(&self) -> <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'_, A, D></h4><a href="#method.t" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1259-1261" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a transposed view of the array.</p>
<p>This is a shorthand for <code>self.view().reversed_axes()</code>.</p>
<p>See also the more general methods <code>.reversed_axes()</code> and <code>.swap_axes()</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.axes" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.axes" class="fnname">axes</a>(&self) -> <a class="struct" href="iter/struct.Axes.html" title="struct ndarray::iter::Axes">Axes</a><'_, D><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><div class="notable">Notable traits for <a class="struct" href="iter/struct.Axes.html" title="struct ndarray::iter::Axes">Axes</a><'a, D></div><code class="content"><span class="where fmt-newline">impl<'a, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="iter/struct.Axes.html" title="struct ndarray::iter::Axes">Axes</a><'a, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></span><span class="where fmt-newline"> type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" class="type">Item</a> = <a class="struct" href="struct.AxisDescription.html" title="struct ndarray::AxisDescription">AxisDescription</a>;</span></code></span></div></span></span></h4><a href="#method.axes" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1264-1266" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an iterator over the length and stride of each axis.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.max_stride_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.max_stride_axis" class="fnname">max_stride_axis</a>(&self) -> <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a></h4><a href="#method.max_stride_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1277-1279" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the axis with the greatest stride (by absolute value),
preferring axes with len > 1.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.invert_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.invert_axis" class="fnname">invert_axis</a>(&mut self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>)</h4><a href="#method.invert_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1284-1293" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Reverse the stride of <code>axis</code>.</p>
<p><em><strong>Panics</strong></em> if the axis is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.merge_axes" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.merge_axes" class="fnname">merge_axes</a>(&mut self, take: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, into: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.merge_axes" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1307-1309" title="goto source code">[src]</a></div></summary><div class="docblock"><p>If possible, merge in the axis <code>take</code> to <code>into</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::Array3</span>;
<span class="kw">use</span> <span class="ident">ndarray::Axis</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Array3</span>::<span class="op"><</span><span class="ident">f64</span><span class="op">></span><span class="ident">::zeros</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>));
<span class="ident">a</span>.<span class="ident">merge_axes</span>(<span class="ident">Axis</span>(<span class="number">1</span>), <span class="ident">Axis</span>(<span class="number">2</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">2</span>, <span class="number">1</span>, <span class="number">12</span>]);</pre></div>
<p><em><strong>Panics</strong></em> if an axis is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.insert_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.insert_axis" class="fnname">insert_axis</a>(self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D::<a class="type" href="trait.Dimension.html#associatedtype.Larger" title="type ndarray::Dimension::Larger">Larger</a>></h4><a href="#method.insert_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1332-1342" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Insert new array axis at <code>axis</code> and return the result.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">Array3</span>, <span class="ident">Axis</span>, <span class="ident">arr1</span>, <span class="ident">arr2</span>};
<span class="comment">// Convert a 1-D array into a row vector (2-D).</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr1</span>(<span class="kw-2">&</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="kw">let</span> <span class="ident">row</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">insert_axis</span>(<span class="ident">Axis</span>(<span class="number">0</span>));
<span class="macro">assert_eq!</span>(<span class="ident">row</span>, <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]]));
<span class="comment">// Convert a 1-D array into a column vector (2-D).</span>
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">arr1</span>(<span class="kw-2">&</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="kw">let</span> <span class="ident">col</span> <span class="op">=</span> <span class="ident">b</span>.<span class="ident">insert_axis</span>(<span class="ident">Axis</span>(<span class="number">1</span>));
<span class="macro">assert_eq!</span>(<span class="ident">col</span>, <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1</span>], [<span class="number">2</span>], [<span class="number">3</span>]]));
<span class="comment">// The new axis always has length 1.</span>
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Array3</span>::<span class="op"><</span><span class="ident">f64</span><span class="op">></span><span class="ident">::zeros</span>((<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>));
<span class="macro">assert_eq!</span>(<span class="ident">b</span>.<span class="ident">insert_axis</span>(<span class="ident">Axis</span>(<span class="number">2</span>)).<span class="ident">shape</span>(), <span class="kw-2">&</span>[<span class="number">3</span>, <span class="number">4</span>, <span class="number">1</span>, <span class="number">5</span>]);</pre></div>
<p><em><strong>Panics</strong></em> if the axis is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.remove_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.remove_axis" class="fnname">remove_axis</a>(self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.remove_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1345-1357" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Remove array axis <code>axis</code> and return the result.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.assign" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.assign" class="fnname">assign</a><E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, S2>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h4><a href="#method.assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1377-1383" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise assigment to <code>self</code> from <code>rhs</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fill" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.fill" class="fnname">fill</a>(&mut self, x: A) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.fill" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1386-1390" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise assigment to <code>self</code> from element <code>x</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.zip_mut_with" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.zip_mut_with" class="fnname">zip_mut_with</a><B, S2, E, F>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>, f: F) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = B>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>A, <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>B), </span></h4><a href="#method.zip_mut_with" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1450-1465" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Traverse two arrays in unspecified order, in lock step,
calling the closure <code>f</code> on each element pair.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fold" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.fold" class="fnname">fold</a><'a, F, B>(&'a self, init: B, f: F) -> B <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(B, <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A) -> B,<br> A: 'a, </span></h4><a href="#method.fold" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1471-1489" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Traverse the array elements and apply a fold,
returning the resulting value.</p>
<p>Elements are visited in arbitrary order.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map" class="fnname">map</a><'a, B, F>(&'a self, f: F) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><B, D> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A) -> B,<br> A: 'a, </span></h4><a href="#method.map" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1509-1525" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Call <code>f</code> by reference on each element and create a new array
with the new values.</p>
<p>Elements are visited in arbitrary order.</p>
<p>Return an array with the same shape as <code>self</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[ <span class="number">0.</span>, <span class="number">1.</span>],
[<span class="op">-</span><span class="number">1.</span>, <span class="number">2.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">x</span> <span class="op">></span><span class="op">=</span> <span class="number">1.0</span>)
<span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="bool-val">false</span>, <span class="bool-val">true</span>],
[<span class="bool-val">false</span>, <span class="bool-val">true</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mapv" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.mapv" class="fnname">mapv</a><B, F>(&self, f: F) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><B, D> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.Fn.html" title="trait core::ops::function::Fn">Fn</a>(A) -> B,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.mapv" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1544-1549" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Call <code>f</code> by <strong>v</strong>alue on each element and create a new array
with the new values.</p>
<p>Elements are visited in arbitrary order.</p>
<p>Return an array with the same shape as <code>self</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[ <span class="number">0.</span>, <span class="number">1.</span>],
[<span class="op">-</span><span class="number">1.</span>, <span class="number">2.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">mapv</span>(<span class="ident">f32::abs</span>) <span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">0.</span>, <span class="number">1.</span>],
[<span class="number">1.</span>, <span class="number">2.</span>]])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mapv_into" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.mapv_into" class="fnname">mapv_into</a><F>(self, f: F) -> Self <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.Fn.html" title="trait core::ops::function::Fn">Fn</a>(A) -> A,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.mapv_into" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1555-1562" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Call <code>f</code> by <strong>v</strong>alue on each element, update the array with the new values
and return it.</p>
<p>Elements are visited in arbitrary order.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map_inplace" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map_inplace" class="fnname">map_inplace</a><F>(&mut self, f: F) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.Fn.html" title="trait core::ops::function::Fn">Fn</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>A), </span></h4><a href="#method.map_inplace" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1567-1572" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Modify the array in place by calling <code>f</code> by mutable reference on each element.</p>
<p>Elements are visited in arbitrary order.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mapv_inplace" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.mapv_inplace" class="fnname">mapv_inplace</a><F>(&mut self, f: F) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.Fn.html" title="trait core::ops::function::Fn">Fn</a>(A) -> A,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.mapv_inplace" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1590-1596" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Modify the array in place by calling <code>f</code> by <strong>v</strong>alue on each element.
The array is updated with the new values.</p>
<p>Elements are visited in arbitrary order.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[ <span class="number">0.</span>, <span class="number">1.</span>],
[<span class="op">-</span><span class="number">1.</span>, <span class="number">2.</span>]]);
<span class="ident">a</span>.<span class="ident">mapv_inplace</span>(<span class="ident">f32::exp</span>);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">all_close</span>(<span class="kw-2">&</span><span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.00000</span>, <span class="number">2.71828</span>],
[<span class="number">0.36788</span>, <span class="number">7.38906</span>]]), <span class="number">1e-5</span>)
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.visit" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.visit" class="fnname">visit</a><'a, F>(&'a self, f: F) <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A),<br> A: 'a, </span></h4><a href="#method.visit" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1602-1607" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Visit each element in the array by calling <code>f</code> by reference
on each element.</p>
<p>Elements are visited in arbitrary order.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fold_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.fold_axis" class="fnname">fold_axis</a><B, F>(<br> &self, <br> axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, <br> init: B, <br> fold: F<br>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><B, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>B, <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>A) -> B,<br> B: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.fold_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1615-1626" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Fold along an axis.</p>
<p>Combine the elements of each subview with the previous using the <code>fold</code>
function and initial value <code>init</code>.</p>
<p>Return the result as an <code>Array</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map_axis" class="fnname">map_axis</a><'a, B, F>(<br> &'a self, <br> axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, <br> mapping: F<br>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><B, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="type" href="type.ArrayView1.html" title="type ndarray::ArrayView1">ArrayView1</a><'a, A>) -> B,<br> A: 'a, </span></h4><a href="#method.map_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_methods.rs.html#1636-1651" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Reduce the values along an axis into just one value, producing a new
array with one less dimension.</p>
<p>Elements are visited in arbitrary order.</p>
<p>Return the result as an <code>Array</code>.</p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-4" class="impl has-srclink"><h3 class="code-header in-band">impl<A, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><<a class="struct" href="struct.OwnedRepr.html" title="struct ndarray::OwnedRepr">OwnedRepr</a><A>, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_owned_array.rs.html#8-19" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Methods specific to <code>Array</code>.</p>
<p><em><strong>See also all methods for <a href="struct.ArrayBase.html"><code>ArrayBase</code></a></strong></em></p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_raw_vec" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_raw_vec" class="fnname">into_raw_vec</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><A></h4><a href="#method.into_raw_vec" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_owned_array.rs.html#16-18" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a vector of the elements in the array, in the way they are
stored internally.</p>
<p>If the array is in standard memory layout, the logical element order
of the array (<code>.iter()</code> order) and of the returned vector will be the same.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-5" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_1d.rs.html#13-26" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_vec" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.to_vec" class="fnname">to_vec</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><A> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h4><a href="#method.to_vec" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_1d.rs.html#17-25" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an vector with the elements of the one-dimensional array.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-6" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#13-64" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.row" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.row" class="fnname">row</a>(&self, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="type" href="type.ArrayView1.html" title="type ndarray::ArrayView1">ArrayView1</a><'_, A></h4><a href="#method.row" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#19-22" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an array view of row <code>index</code>.</p>
<p><strong>Panics</strong> if <code>index</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.row_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.row_mut" class="fnname">row_mut</a>(&mut self, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="type" href="type.ArrayViewMut1.html" title="type ndarray::ArrayViewMut1">ArrayViewMut1</a><'_, A> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.row_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#27-31" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a mutable array view of row <code>index</code>.</p>
<p><strong>Panics</strong> if <code>index</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rows" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.rows" class="fnname">rows</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a></h4><a href="#method.rows" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#34-36" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the number of rows (length of <code>Axis(0)</code>) in the two-dimensional array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.column" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.column" class="fnname">column</a>(&self, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="type" href="type.ArrayView1.html" title="type ndarray::ArrayView1">ArrayView1</a><'_, A></h4><a href="#method.column" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#41-44" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return an array view of column <code>index</code>.</p>
<p><strong>Panics</strong> if <code>index</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.column_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.column_mut" class="fnname">column_mut</a>(&mut self, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="type" href="type.ArrayViewMut1.html" title="type ndarray::ArrayViewMut1">ArrayViewMut1</a><'_, A> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h4><a href="#method.column_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#49-53" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return a mutable array view of column <code>index</code>.</p>
<p><strong>Panics</strong> if <code>index</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.cols" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.cols" class="fnname">cols</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a></h4><a href="#method.cols" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#56-58" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the number of columns (length of <code>Axis(1)</code>) in the two-dimensional array.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_square" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.is_square" class="fnname">is_square</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.is_square" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_2d.rs.html#61-63" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return true if the array is square, false otherwise.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-7" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-7" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#23-157" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Numerical methods for arrays.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.scalar_sum" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.scalar_sum" class="fnname">scalar_sum</a>(&self) -> A <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><Output = A> + <a class="trait" href="../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a>, </span></h4><a href="#method.scalar_sum" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#36-51" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the sum of all elements in the array.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]]);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">scalar_sum</span>(), <span class="number">10.</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sum_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.sum_axis" class="fnname">sum_axis</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><Output = A>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.sum_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#69-89" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return sum along <code>axis</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">aview0</span>, <span class="ident">aview1</span>, <span class="ident">arr2</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">sum_axis</span>(<span class="ident">Axis</span>(<span class="number">0</span>)) <span class="op">=</span><span class="op">=</span> <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">4.</span>, <span class="number">6.</span>]) <span class="op">&&</span>
<span class="ident">a</span>.<span class="ident">sum_axis</span>(<span class="ident">Axis</span>(<span class="number">1</span>)) <span class="op">=</span><span class="op">=</span> <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">3.</span>, <span class="number">7.</span>]) <span class="op">&&</span>
<span class="ident">a</span>.<span class="ident">sum_axis</span>(<span class="ident">Axis</span>(<span class="number">0</span>)).<span class="ident">sum_axis</span>(<span class="ident">Axis</span>(<span class="number">0</span>)) <span class="op">=</span><span class="op">=</span> <span class="ident">aview0</span>(<span class="kw-2">&</span><span class="number">10.</span>)
);</pre></div>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sum" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.sum" class="fnname">sum</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><Output = A>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.sum" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#93-98" title="goto source code">[src]</a></div><div class="item-info"><div class="stab deprecated"><span class="emoji">👎</span> Deprecated: <p>Use new name .sum_axis()</p>
</div></div></summary><div class="docblock"><p>Old name for <code>sum_axis</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mean_axis" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.mean_axis" class="fnname">mean_axis</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.mean_axis" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#114-125" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return mean along <code>axis</code>.</p>
<p><strong>Panics</strong> if <code>axis</code> is out of bounds.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray</span>::{<span class="ident">aview1</span>, <span class="ident">arr2</span>, <span class="ident">Axis</span>};
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">3.</span>, <span class="number">4.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">mean_axis</span>(<span class="ident">Axis</span>(<span class="number">0</span>)) <span class="op">=</span><span class="op">=</span> <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">2.0</span>, <span class="number">3.0</span>]) <span class="op">&&</span>
<span class="ident">a</span>.<span class="ident">mean_axis</span>(<span class="ident">Axis</span>(<span class="number">1</span>)) <span class="op">=</span><span class="op">=</span> <span class="ident">aview1</span>(<span class="kw-2">&</span>[<span class="number">1.5</span>, <span class="number">3.5</span>])
);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mean" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.mean" class="fnname">mean</a>(&self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D::<a class="type" href="trait.Dimension.html#associatedtype.Smaller" title="type ndarray::Dimension::Smaller">Smaller</a>> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>,<br> D: <a class="trait" href="trait.RemoveAxis.html" title="trait ndarray::RemoveAxis">RemoveAxis</a>, </span></h4><a href="#method.mean" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#129-134" title="goto source code">[src]</a></div><div class="item-info"><div class="stab deprecated"><span class="emoji">👎</span> Deprecated: <p>Use new name .mean_axis()</p>
</div></div></summary><div class="docblock"><p>Old name for <code>mean_axis</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.all_close" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.all_close" class="fnname">all_close</a><S2, E>(&self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>, tol: A) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> A: <a class="trait" href="../num_traits/float/trait.Float.html" title="trait num_traits::float::Float">Float</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h4><a href="#method.all_close" class="anchor"></a><a class="srclink" href="../src/ndarray/numeric/impl_numeric.rs.html#142-156" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return <code>true</code> if the arrays’ elementwise differences are all within
the given absolute tolerance, <code>false</code> otherwise.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting to the same shape isn’t possible.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-8" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-8" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#42-132" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.dot" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.dot" class="fnname">dot</a><Rhs>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <Self as <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><Rhs>>::<a class="type" href="linalg/trait.Dot.html#associatedtype.Output" title="type ndarray::linalg::Dot::Output">Output</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><Rhs>, </span></h4><a href="#method.dot" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#62-66" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform dot product or matrix multiplication of arrays <code>self</code> and <code>rhs</code>.</p>
<p><code>Rhs</code> may be either a one-dimensional or a two-dimensional array.</p>
<p>If <code>Rhs</code> is one-dimensional, then the operation is a vector dot
product, which is the sum of the elementwise products (no conjugation
of complex operands, and thus not their inner product). In this case,
<code>self</code> and <code>rhs</code> must be the same length.</p>
<p>If <code>Rhs</code> is two-dimensional, then the operation is matrix
multiplication, where <code>self</code> is treated as a row vector. In this case,
if <code>self</code> is shape <em>M</em>, then <code>rhs</code> is shape <em>M</em> × <em>N</em> and the result is
shape <em>N</em>.</p>
<p><strong>Panics</strong> if the array shapes are incompatible.<br>
<em>Note:</em> If enabled, uses blas <code>dot</code> for elements of <code>f32, f64</code> when memory
layout allows.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-9" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-9" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#210-245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.dot-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.dot-1" class="fnname">dot</a><Rhs>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <Self as <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><Rhs>>::<a class="type" href="linalg/trait.Dot.html#associatedtype.Output" title="type ndarray::linalg::Dot::Output">Output</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><Rhs>, </span></h4><a href="#method.dot-1" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#240-244" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform matrix multiplication of rectangular arrays <code>self</code> and <code>rhs</code>.</p>
<p><code>Rhs</code> may be either a one-dimensional or a two-dimensional array.</p>
<p>If Rhs is two-dimensional, they array shapes must agree in the way that
if <code>self</code> is <em>M</em> × <em>N</em>, then <code>rhs</code> is <em>N</em> × <em>K</em>.</p>
<p>Return a result array with shape <em>M</em> × <em>K</em>.</p>
<p><strong>Panics</strong> if shapes are incompatible.<br>
<em>Note:</em> If enabled, uses blas <code>gemv/gemm</code> for elements of <code>f32, f64</code>
when memory layout allows. The default matrixmultiply backend
is otherwise used for <code>f32, f64</code> for all memory layouts.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::arr2</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">0.</span>, <span class="number">1.</span>]]);
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">1.</span>, <span class="number">2.</span>],
[<span class="number">2.</span>, <span class="number">3.</span>]]);
<span class="macro">assert!</span>(
<span class="ident">a</span>.<span class="ident">dot</span>(<span class="kw-2">&</span><span class="ident">b</span>) <span class="op">=</span><span class="op">=</span> <span class="ident">arr2</span>(<span class="kw-2">&</span>[[<span class="number">5.</span>, <span class="number">8.</span>],
[<span class="number">2.</span>, <span class="number">3.</span>]])
);</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-10" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-10" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#325-344" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.scaled_add" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.scaled_add" class="fnname">scaled_add</a><S2, E>(&mut self, alpha: A, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h4><a href="#method.scaled_add" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#336-343" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform the operation <code>self += alpha * rhs</code> efficiently, where
<code>alpha</code> is a scalar and <code>rhs</code> is another array. This operation is
also known as <code>axpy</code> in BLAS.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-11" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><<a class="struct" href="struct.ViewRepr.html" title="struct ndarray::ViewRepr">ViewRepr</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A>, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#30-137" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Methods for read-only array views.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_shape" class="fnname">from_shape</a><Sh>(shape: Sh, xs: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&'a [A]</a>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, <a class="struct" href="struct.ShapeError.html" title="struct ndarray::ShapeError">ShapeError</a>> <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#57-69" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a read-only array view borrowing its data from a slice.</p>
<p>Checks whether <code>shape</code> are compatible with the slice’s
length, returning an <code>Err</code> if not compatible.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::ArrayView</span>;
<span class="kw">use</span> <span class="ident">ndarray::arr3</span>;
<span class="kw">use</span> <span class="ident">ndarray::ShapeBuilder</span>;
<span class="kw">let</span> <span class="ident">s</span> <span class="op">=</span> [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">10</span>, <span class="number">11</span>, <span class="number">12</span>];
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">ArrayView::from_shape</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span>).<span class="ident">strides</span>((<span class="number">1</span>, <span class="number">4</span>, <span class="number">2</span>)),
<span class="kw-2">&</span><span class="ident">s</span>).<span class="ident">unwrap</span>();
<span class="macro">assert!</span>(
<span class="ident">a</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[<span class="number">0</span>, <span class="number">2</span>],
[<span class="number">4</span>, <span class="number">6</span>],
[<span class="number">8</span>, <span class="number">10</span>]],
[[<span class="number">1</span>, <span class="number">3</span>],
[<span class="number">5</span>, <span class="number">7</span>],
[<span class="number">9</span>, <span class="number">11</span>]]])
);
<span class="macro">assert!</span>(<span class="ident">a</span>.<span class="ident">strides</span>() <span class="op">=</span><span class="op">=</span> <span class="kw-2">&</span>[<span class="number">1</span>, <span class="number">4</span>, <span class="number">2</span>]);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape_ptr" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.from_shape_ptr" class="fnname">from_shape_ptr</a><Sh>(shape: Sh, ptr: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.pointer.html">*const A</a>) -> Self <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape_ptr" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#76-83" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an <code>ArrayView<A, D></code> from shape information and a
raw pointer to the elements.</p>
<p>Unsafe because caller is responsible for ensuring that the pointer is
valid, not mutably aliased and coherent with the dimension and stride information.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.split_at" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.split_at" class="fnname">split_at</a>(self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">)</a></h4><a href="#method.split_at" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#94-123" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Split the array view along <code>axis</code> and return one view strictly before the
split and one view after the split.</p>
<p><strong>Panics</strong> if <code>axis</code> or <code>index</code> is out of bounds.</p>
<p>Below, an illustration of <code>.split_at(Axis(2), 2)</code> on
an array with shape 3 × 5 × 5.</p>
<img src="https://bluss.github.io/ndarray/images/split_at.svg" width="300px" height="271px"></div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_slice" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_slice" class="fnname">into_slice</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&'a [A]</a>></h4><a href="#method.into_slice" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#127-135" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice, if it is contiguous and in standard order.
Return <code>None</code> otherwise.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-12" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, D> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><<a class="struct" href="struct.ViewRepr.html" title="struct ndarray::ViewRepr">ViewRepr</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>A>, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#275-372" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Methods for read-write array views.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.from_shape-1" class="fnname">from_shape</a><Sh>(shape: Sh, xs: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&'a mut [A]</a>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, <a class="struct" href="struct.ShapeError.html" title="struct ndarray::ShapeError">ShapeError</a>> <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#303-315" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create a read-write array view borrowing its data from a slice.</p>
<p>Checks whether <code>dim</code> and <code>strides</code> are compatible with the slice’s
length, returning an <code>Err</code> if not compatible.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">ndarray::ArrayViewMut</span>;
<span class="kw">use</span> <span class="ident">ndarray::arr3</span>;
<span class="kw">use</span> <span class="ident">ndarray::ShapeBuilder</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">10</span>, <span class="number">11</span>, <span class="number">12</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">ArrayViewMut::from_shape</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span>).<span class="ident">strides</span>((<span class="number">1</span>, <span class="number">4</span>, <span class="number">2</span>)),
<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">s</span>).<span class="ident">unwrap</span>();
<span class="ident">a</span>[[<span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>]] <span class="op">=</span> <span class="number">1</span>;
<span class="macro">assert!</span>(
<span class="ident">a</span> <span class="op">=</span><span class="op">=</span> <span class="ident">arr3</span>(<span class="kw-2">&</span>[[[<span class="number">1</span>, <span class="number">2</span>],
[<span class="number">4</span>, <span class="number">6</span>],
[<span class="number">8</span>, <span class="number">10</span>]],
[[<span class="number">1</span>, <span class="number">3</span>],
[<span class="number">5</span>, <span class="number">7</span>],
[<span class="number">9</span>, <span class="number">11</span>]]])
);
<span class="macro">assert!</span>(<span class="ident">a</span>.<span class="ident">strides</span>() <span class="op">=</span><span class="op">=</span> <span class="kw-2">&</span>[<span class="number">1</span>, <span class="number">4</span>, <span class="number">2</span>]);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_shape_ptr-1" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.from_shape_ptr-1" class="fnname">from_shape_ptr</a><Sh>(shape: Sh, ptr: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.pointer.html">*mut A</a>) -> Self <span class="where fmt-newline">where<br> Sh: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="struct" href="struct.StrideShape.html" title="struct ndarray::StrideShape">StrideShape</a><D>>, </span></h4><a href="#method.from_shape_ptr-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#322-329" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an <code>ArrayViewMut<A, D></code> from shape information and a
raw pointer to the elements.</p>
<p>Unsafe because caller is responsible for ensuring that the pointer is
valid, not aliased and coherent with the dimension and stride information.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.split_at-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.split_at-1" class="fnname">split_at</a>(self, axis: <a class="struct" href="struct.Axis.html" title="struct ndarray::Axis">Axis</a>, index: <a class="type" href="type.Ix.html" title="type ndarray::Ix">Ix</a>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">)</a></h4><a href="#method.split_at-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#335-364" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Split the array view along <code>axis</code> and return one mutable view strictly
before the split and one mutable view after the split.</p>
<p><strong>Panics</strong> if <code>axis</code> or <code>index</code> is out of bounds.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_slice-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.into_slice-1" class="fnname">into_slice</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&'a mut [A]</a>></h4><a href="#method.into_slice-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_views.rs.html#368-370" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return the array’s data as a slice, if it is contiguous and in standard order.
Return <code>None</code> otherwise.</p>
</div></details></div></details><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-95" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-95" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.add-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-97" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-97" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.add-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#270" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-115" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#associatedtype.Output-115" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-26" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#method.add-26" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#270" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#275" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-117" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#associatedtype.Output-117" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-28" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#method.add-28" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#275" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-99" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-99" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.add-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-101" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-101" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.add-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-103" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-103" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.add-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-105" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-105" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.add-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-107" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-107" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.add-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-109" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-109" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.add-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#258" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-111" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#associatedtype.Output-111" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#method.add-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#258" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#264" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-113" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#associatedtype.Output-113" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-24" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#method.add-24" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#264" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
addition
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-90" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-90" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
addition
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-91" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-91" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.add-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-94" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-94" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-96" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-96" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#270" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-114" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-114" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-25" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-25" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#270" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#275" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-116" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-116" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-27" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-27" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#275" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-98" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-98" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-100" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-100" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-102" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-102" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-104" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-104" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-106" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-106" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-108" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-108" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#258" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-110" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-110" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#258" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#264" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-112" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-112" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-23" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-23" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#264" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Add%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
addition
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-89" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-89" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Add%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
addition
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-92" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-92" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.add-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Add%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Add%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
addition
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-93" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-93" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add" class="fnname">add</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.add-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#220" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html#tymethod.add">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-AddAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-AddAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#379-380" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self += rhs</code> as elementwise addition (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html#tymethod.add_assign" class="fnname">add_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.add_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#379-380" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html#tymethod.add_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-AddAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-AddAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#379-380" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self += rhs</code> as elementwise addition (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.add_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html#tymethod.add_assign" class="fnname">add_assign</a>(&mut self, rhs: A)</h4><a href="#method.add_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#379-380" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>+=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html#tymethod.add_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Binary" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Binary.html" title="trait core::fmt::Binary">Binary</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Binary.html" title="trait core::fmt::Binary">Binary</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-Binary" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#154-160" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>Binary</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Binary.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt-4" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#157-159" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-157" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-157" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.bitand-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-159" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-159" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.bitand-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-161" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-161" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.bitand-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-163" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-163" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.bitand-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-165" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-165" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.bitand-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-167" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-167" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.bitand-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-169" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-169" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.bitand-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-171" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-171" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.bitand-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#254" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-173" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#associatedtype.Output-173" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#method.bitand-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#254" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit and
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-152" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-152" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit and
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-153" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-153" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitand-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-156" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-156" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-158" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-158" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-160" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-160" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-162" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-162" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-164" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-164" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-166" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-166" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-168" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-168" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-170" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-170" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#254" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-172" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-172" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#254" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAnd%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit and
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-151" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-151" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitAnd%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit and
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-154" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-154" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitand-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAnd%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html" title="trait core::ops::bit::BitAnd">BitAnd</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitAnd%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit and
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-155" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-155" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>&</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand" class="fnname">bitand</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitand-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#225" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAnd.html#tymethod.bitand">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAndAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html" title="trait core::ops::bit::BitAndAssign">BitAndAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html" title="trait core::ops::bit::BitAndAssign">BitAndAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAndAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#389-390" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self &= rhs</code> as elementwise bit and (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html#tymethod.bitand_assign" class="fnname">bitand_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.bitand_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#389-390" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html#tymethod.bitand_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitAndAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html" title="trait core::ops::bit::BitAndAssign">BitAndAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html" title="trait core::ops::bit::BitAndAssign">BitAndAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitAndAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#389-390" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self &= rhs</code> as elementwise bit and (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitand_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html#tymethod.bitand_assign" class="fnname">bitand_assign</a>(&mut self, rhs: A)</h4><a href="#method.bitand_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#389-390" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>&=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitAndAssign.html#tymethod.bitand_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-180" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-180" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.bitor-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-182" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-182" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.bitor-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-184" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-184" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.bitor-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-186" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-186" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.bitor-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-188" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-188" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.bitor-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-190" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-190" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.bitor-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-192" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-192" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.bitor-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-194" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-194" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.bitor-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#255" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-196" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#associatedtype.Output-196" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#method.bitor-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#255" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit or
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-175" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-175" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit or
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-176" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-176" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitor-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-179" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-179" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-181" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-181" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-183" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-183" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-185" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-185" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-187" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-187" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-189" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-189" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-191" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-191" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-193" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-193" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#255" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-195" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-195" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#255" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOr%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit or
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-174" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-174" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitOr%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit or
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-177" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-177" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitor-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOr%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html" title="trait core::ops::bit::BitOr">BitOr</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitOr%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit or
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-178" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-178" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>|</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor" class="fnname">bitor</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitor-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#226" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOr.html#tymethod.bitor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html" title="trait core::ops::bit::BitOrAssign">BitOrAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html" title="trait core::ops::bit::BitOrAssign">BitOrAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#391-392" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self |= rhs</code> as elementwise bit or (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html#tymethod.bitor_assign" class="fnname">bitor_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.bitor_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#391-392" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html#tymethod.bitor_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitOrAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html" title="trait core::ops::bit::BitOrAssign">BitOrAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html" title="trait core::ops::bit::BitOrAssign">BitOrAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitOrAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#391-392" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self |= rhs</code> as elementwise bit or (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitor_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html#tymethod.bitor_assign" class="fnname">bitor_assign</a>(&mut self, rhs: A)</h4><a href="#method.bitor_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#391-392" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>|=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitOrAssign.html#tymethod.bitor_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-203" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-203" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.bitxor-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-205" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-205" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.bitxor-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-207" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-207" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.bitxor-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-209" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-209" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.bitxor-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-211" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-211" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.bitxor-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-213" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-213" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.bitxor-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-215" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-215" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.bitxor-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-217" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-217" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.bitxor-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#256" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-219" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#associatedtype.Output-219" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, D></h4><a href="#method.bitxor-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#256" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit xor
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-198" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-198" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit xor
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-199" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-199" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitxor-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-202" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-202" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-204" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-204" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-206" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-206" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-208" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-208" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-210" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-210" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-212" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-212" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-214" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-214" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-216" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-216" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#256" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-218" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-218" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#256" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXor%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit xor
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-197" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-197" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitXor%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit xor
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-200" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-200" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.bitxor-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXor%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html" title="trait core::ops::bit::BitXor">BitXor</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-BitXor%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
bit xor
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-201" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-201" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>^</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor" class="fnname">bitxor</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.bitxor-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#227" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXor.html#tymethod.bitxor">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXorAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html" title="trait core::ops::bit::BitXorAssign">BitXorAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html" title="trait core::ops::bit::BitXorAssign">BitXorAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXorAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#393-394" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self ^= rhs</code> as elementwise bit xor (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html#tymethod.bitxor_assign" class="fnname">bitxor_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.bitxor_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#393-394" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html#tymethod.bitxor_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BitXorAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html" title="trait core::ops::bit::BitXorAssign">BitXorAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html" title="trait core::ops::bit::BitXorAssign">BitXorAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-BitXorAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#393-394" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self ^= rhs</code> as elementwise bit xor (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.bitxor_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html#tymethod.bitxor_assign" class="fnname">bitxor_assign</a>(&mut self, rhs: A)</h4><a href="#method.bitxor_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#393-394" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>^=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.BitXorAssign.html#tymethod.bitxor_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Clone" class="impl has-srclink"><h3 class="code-header in-band">impl<S: <a class="trait" href="trait.DataClone.html" title="trait ndarray::DataClone">DataClone</a>, D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h3><a href="#impl-Clone" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_clone.rs.html#11-34" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone_from" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#method.clone_from" class="fnname">clone_from</a>(&mut self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Self)</h4><a href="#method.clone_from" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_clone.rs.html#27-33" title="goto source code">[src]</a></div></summary><div class="docblock"><p><code>Array</code> implements <code>.clone_from()</code> to reuse an array’s existing
allocation. Semantically equivalent to <code>*self = other.clone()</code>, but
potentially more efficient.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#tymethod.clone" class="fnname">clone</a>(&self) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.clone" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_clone.rs.html#12-22" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Debug" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-Debug" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#103-113" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>Debug</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#106-112" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Default" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></h3><a href="#impl-Default" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#307-317" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Create an owned array with a default state.</p>
<p>The array is created with dimension <code>D::default()</code>, which results
in for example dimensions <code>0</code> and <code>(0, 0)</code> with zero elements for the
one-dimensional and two-dimensional cases respectively.</p>
<p>The default dimension for <code>IxDyn</code> is <code>IxDyn(&[0])</code> (array has zero
elements). And the default for the dimension <code>()</code> is <code>()</code> (array has
one element).</p>
<p>Since arrays cannot grow, the intention is to use the default value as
placeholder.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.default-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html#tymethod.default" class="fnname">default</a>() -> Self</h4><a href="#method.default-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#314-316" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Returns the “default value” for a type. <a href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html#tymethod.default">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Display" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-Display" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#91-97" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>Display</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Display.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#94-96" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Display.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-12" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-12" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.div-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-14" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-14" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.div-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#273" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-32" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#associatedtype.Output-32" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-26" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#method.div-26" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#273" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#278" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-34" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#associatedtype.Output-34" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-28" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#method.div-28" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#278" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-16" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-16" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.div-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-18" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-18" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.div-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-20" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-20" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.div-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-22" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-22" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.div-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-24" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-24" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.div-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-26" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-26" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.div-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#261" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-28" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#associatedtype.Output-28" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#method.div-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#261" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#267" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-30" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#associatedtype.Output-30" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-24" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#method.div-24" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#267" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
division
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-7" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-7" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
division
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-8" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-8" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.div-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-11" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-11" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-13" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-13" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#273" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-31" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-31" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-25" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-25" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#273" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#278" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-33" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-33" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-27" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-27" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#278" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-15" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-15" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-17" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-17" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-19" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-19" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-21" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-21" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-23" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-23" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-25" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-25" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#261" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-27" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-27" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#261" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#267" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-29" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-29" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-23" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-23" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#267" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Div%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
division
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-6" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-6" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Div%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
division
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-9" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-9" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.div-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Div%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Div%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
division
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-10" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-10" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div" class="fnname">div</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.div-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#223" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html#tymethod.div">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-DivAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-DivAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#385-386" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self /= rhs</code> as elementwise division (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html#tymethod.div_assign" class="fnname">div_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.div_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#385-386" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html#tymethod.div_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-DivAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-DivAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#385-386" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self /= rhs</code> as elementwise division (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.div_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html#tymethod.div_assign" class="fnname">div_assign</a>(&mut self, rhs: A)</h4><a href="#method.div_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#385-386" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>/=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html#tymethod.div_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%201%5D%3E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2> <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="struct" href="struct.Dim.html" title="struct ndarray::Dim">Dim</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">[</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">; 1]</a>>>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>, </span></h3><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%201%5D%3E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#167-186" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.dot-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="linalg/trait.Dot.html#tymethod.dot" class="fnname">dot</a>(&self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>>) -> A</h4><a href="#method.dot-2" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#182-185" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Compute the dot product of one-dimensional arrays.</p>
<p>The dot product is a sum of the elementwise products (no conjugation
of complex operands, and thus not their inner product).</p>
<p><strong>Panics</strong> if the arrays are not of the same length.<br>
<em>Note:</em> If enabled, uses blas <code>dot</code> for elements of <code>f32, f64</code> when memory
layout allows.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-2" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="linalg/trait.Dot.html#associatedtype.Output" class="type">Output</a> = A</h4><a href="#associatedtype.Output-2" class="anchor"></a></div></summary><div class='docblock'><p>The result of the operation. <a href="linalg/trait.Dot.html#associatedtype.Output">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%201%5D%3E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2> <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="struct" href="struct.Dim.html" title="struct ndarray::Dim">Dim</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">[</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">; 1]</a>>>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>, </span></h3><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%201%5D%3E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#303-323" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform the matrix multiplication of the rectangular array <code>self</code> and
column vector <code>rhs</code>.</p>
<p>The array shapes must agree in the way that
if <code>self</code> is <em>M</em> × <em>N</em>, then <code>rhs</code> is <em>N</em>.</p>
<p>Return a result array with shape <em>M</em>.</p>
<p><strong>Panics</strong> if shapes are incompatible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-5" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="linalg/trait.Dot.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>></h4><a href="#associatedtype.Output-5" class="anchor"></a></div></summary><div class='docblock'><p>The result of the operation. <a href="linalg/trait.Dot.html#associatedtype.Output">Read more</a></p>
</div></details><div id="method.dot-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="linalg/trait.Dot.html#tymethod.dot" class="fnname">dot</a>(&self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>></h4><a href="#method.dot-5" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#309-322" title="goto source code">[src]</a></div></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%202%5D%3E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2> <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="struct" href="struct.Dim.html" title="struct ndarray::Dim">Dim</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">[</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">; 2]</a>>>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>, </span></h3><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%202%5D%3E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#188-208" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.dot-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="linalg/trait.Dot.html#tymethod.dot" class="fnname">dot</a>(&self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>></h4><a href="#method.dot-3" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#204-207" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform the matrix multiplication of the row vector <code>self</code> and
rectangular matrix <code>rhs</code>.</p>
<p>The array shapes must agree in the way that
if <code>self</code> is <em>M</em>, then <code>rhs</code> is <em>M</em> × <em>N</em>.</p>
<p>Return a result array with shape <em>N</em>.</p>
<p><strong>Panics</strong> if shapes are incompatible.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-3" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="linalg/trait.Dot.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>></h4><a href="#associatedtype.Output-3" class="anchor"></a></div></summary><div class='docblock'><p>The result of the operation. <a href="linalg/trait.Dot.html#associatedtype.Output">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%202%5D%3E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2> <a class="trait" href="linalg/trait.Dot.html" title="trait ndarray::linalg::Dot">Dot</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="struct" href="struct.Dim.html" title="struct ndarray::Dim">Dim</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">[</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html">usize</a><a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.array.html">; 2]</a>>>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> A: <a class="trait" href="trait.LinalgScalar.html" title="trait ndarray::LinalgScalar">LinalgScalar</a>, </span></h3><a href="#impl-Dot%3CArrayBase%3CS2%2C%20Dim%3C%5Busize%3B%202%5D%3E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#247-275" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-4" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="linalg/trait.Dot.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array2.html" title="type ndarray::Array2">Array2</a><A></h4><a href="#associatedtype.Output-4" class="anchor"></a></div></summary><div class='docblock'><p>The result of the operation. <a href="linalg/trait.Dot.html#associatedtype.Output">Read more</a></p>
</div></details><div id="method.dot-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="linalg/trait.Dot.html#tymethod.dot" class="fnname">dot</a>(&self, b: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, <a class="type" href="type.Ix2.html" title="type ndarray::Ix2">Ix2</a>>) -> <a class="type" href="type.Array2.html" title="type ndarray::Array2">Array2</a><A></h4><a href="#method.dot-4" class="anchor"></a><a class="srclink" href="../src/ndarray/linalg/impl_linalg.rs.html#253-274" title="goto source code">[src]</a></div></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'a, A, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-From%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#233-240" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Implementation of <code>ArrayView::from(&A)</code> where <code>A</code> is an array.</p>
<p>Create a read-only array view of the array.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(array: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> Self</h4><a href="#method.from" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#237-239" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3C%26%27a%20mut%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a mut <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'a, A, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-From%3C%26%27a%20mut%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#259-266" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Implementation of <code>ArrayViewMut::from(&mut A)</code> where <code>A</code> is an array.</p>
<p>Create a read-write array view of the array.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(array: &'a mut <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> Self</h4><a href="#method.from-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#263-265" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-FromIterator%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html" title="trait core::iter::traits::collect::FromIterator">FromIterator</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A>, </span></h3><a href="#impl-FromIterator%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#115-123" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_iter-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter" class="fnname">from_iter</a><I>(iterable: I) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, <a class="type" href="type.Ix1.html" title="type ndarray::Ix1">Ix1</a>> <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a><Item = A>, </span></h4><a href="#method.from_iter-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#118-122" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates a value from an iterator. <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Hash" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>,<br> S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>, </span></h3><a href="#impl-Hash" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#171-193" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.hash" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#tymethod.hash" class="fnname">hash</a><H: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>>(&self, state: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>H)</h4><a href="#method.hash" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#177-192" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Feeds this value into the given <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.hash_slice" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#method.hash_slice" class="fnname">hash_slice</a><H>(data: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>H) <span class="where fmt-newline">where<br> H: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></h4><span class="since" title="Stable since Rust version 1.3.0">1.3.0</span><a href="#method.hash_slice" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/hash/mod.rs.html#211-213" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Feeds a slice of this type into the given <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Index%3CI%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D, I> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.Index.html" title="trait core::ops::index::Index">Index</a><I> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>, </span></h3><a href="#impl-Index%3CI%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#47-61" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Access the element at <strong>index</strong>.</p>
<p><strong>Panics</strong> if index is out of bounds.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-262" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.Index.html#associatedtype.Output" class="type">Output</a> = S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a></h4><a href="#associatedtype.Output-262" class="anchor"></a></div></summary><div class='docblock'><p>The returned type after indexing.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.index" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.Index.html#tymethod.index" class="fnname">index</a>(&self, index: I) -> &S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a></h4><a href="#method.index" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#54-60" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the indexing (<code>container[index]</code>) operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.Index.html#tymethod.index">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IndexMut%3CI%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D, I> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.IndexMut.html" title="trait core::ops::index::IndexMut">IndexMut</a><I> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> I: <a class="trait" href="trait.NdIndex.html" title="trait ndarray::NdIndex">NdIndex</a><D>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h3><a href="#impl-IndexMut%3CI%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#66-79" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Access the element at <strong>index</strong> mutably.</p>
<p><strong>Panics</strong> if index is out of bounds.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.index_mut" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.IndexMut.html#tymethod.index_mut" class="fnname">index_mut</a>(&mut self, index: I) -> &mut S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a></h4><a href="#method.index_mut" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#72-78" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the mutable indexing (<code>container[index]</code>) operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/index/trait.IndexMut.html#tymethod.index_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoIterator" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>, </span></h3><a href="#impl-IntoIterator" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#125-135" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item-2" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="type">Item</a> = &'a S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a></h4><a href="#associatedtype.Item-2" class="anchor"></a></div></summary><div class='docblock'><p>The type of the elements being iterated over.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.IntoIter" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="type">IntoIter</a> = <a class="struct" href="iter/struct.Iter.html" title="struct ndarray::iter::Iter">Iter</a><'a, S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>, D></h4><a href="#associatedtype.IntoIter" class="anchor"></a></div></summary><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_iter" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fnname">into_iter</a>(self) -> Self::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" title="type core::iter::traits::collect::IntoIterator::IntoIter">IntoIter</a></h4><a href="#method.into_iter" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#132-134" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoIterator-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &'a mut <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>, </span></h3><a href="#impl-IntoIterator-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#137-147" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item-3" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="type">Item</a> = &'a mut S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a></h4><a href="#associatedtype.Item-3" class="anchor"></a></div></summary><div class='docblock'><p>The type of the elements being iterated over.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.IntoIter-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="type">IntoIter</a> = <a class="struct" href="iter/struct.IterMut.html" title="struct ndarray::iter::IterMut">IterMut</a><'a, S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>, D></h4><a href="#associatedtype.IntoIter-1" class="anchor"></a></div></summary><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_iter-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fnname">into_iter</a>(self) -> Self::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" title="type core::iter::traits::collect::IntoIterator::IntoIter">IntoIter</a></h4><a href="#method.into_iter-1" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#144-146" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoNdProducer" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: 'a, S, D> <a class="trait" href="trait.IntoNdProducer.html" title="trait ndarray::IntoNdProducer">IntoNdProducer</a> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-IntoNdProducer" class="anchor"></a><a class="srclink" href="../src/ndarray/zip/mod.rs.html#210-220" title="goto source code">[src]</a></div></summary><div class="docblock"><p>An array reference is an n-dimensional producer of element references
(like ArrayView).</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A</h4><a href="#associatedtype.Item" class="anchor"></a></div></summary><div class='docblock'><p>The element produced per iteration.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Dim" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Dim" class="type">Dim</a> = D</h4><a href="#associatedtype.Dim" class="anchor"></a></div></summary><div class='docblock'><p>Dimension type of the producer</p>
</div></details><div id="associatedtype.Output" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.ArrayView.html" title="type ndarray::ArrayView">ArrayView</a><'a, A, D></h4><a href="#associatedtype.Output" class="anchor"></a></div><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_producer" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="trait.IntoNdProducer.html#tymethod.into_producer" class="fnname">into_producer</a>(self) -> Self::<a class="type" href="trait.IntoNdProducer.html#associatedtype.Output" title="type ndarray::IntoNdProducer::Output">Output</a></h4><a href="#method.into_producer" class="anchor"></a><a class="srclink" href="../src/ndarray/zip/mod.rs.html#217-219" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Convert the value into an <code>NdProducer</code>.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoNdProducer-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: 'a, S, D> <a class="trait" href="trait.IntoNdProducer.html" title="trait ndarray::IntoNdProducer">IntoNdProducer</a> for &'a mut <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>, </span></h3><a href="#impl-IntoNdProducer-1" class="anchor"></a><a class="srclink" href="../src/ndarray/zip/mod.rs.html#224-234" title="goto source code">[src]</a></div></summary><div class="docblock"><p>A mutable array reference is an n-dimensional producer of mutable element
references (like ArrayViewMut).</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>A</h4><a href="#associatedtype.Item-1" class="anchor"></a></div></summary><div class='docblock'><p>The element produced per iteration.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Dim-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Dim" class="type">Dim</a> = D</h4><a href="#associatedtype.Dim-1" class="anchor"></a></div></summary><div class='docblock'><p>Dimension type of the producer</p>
</div></details><div id="associatedtype.Output-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="trait.IntoNdProducer.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.ArrayViewMut.html" title="type ndarray::ArrayViewMut">ArrayViewMut</a><'a, A, D></h4><a href="#associatedtype.Output-1" class="anchor"></a></div><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_producer-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="trait.IntoNdProducer.html#tymethod.into_producer" class="fnname">into_producer</a>(self) -> Self::<a class="type" href="trait.IntoNdProducer.html#associatedtype.Output" title="type ndarray::IntoNdProducer::Output">Output</a></h4><a href="#method.into_producer-1" class="anchor"></a><a class="srclink" href="../src/ndarray/zip/mod.rs.html#231-233" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Convert the value into an <code>NdProducer</code>.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-LowerExp" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerExp.html" title="trait core::fmt::LowerExp">LowerExp</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerExp.html" title="trait core::fmt::LowerExp">LowerExp</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-LowerExp" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#119-125" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>LowerExp</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerExp.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt-2" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#122-124" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-LowerHex" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerHex.html" title="trait core::fmt::LowerHex">LowerHex</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerHex.html" title="trait core::fmt::LowerHex">LowerHex</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-LowerHex" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#142-148" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>LowerHex</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.LowerHex.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt-5" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#145-147" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-124" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-124" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.mul-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-126" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-126" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.mul-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#272" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-144" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#associatedtype.Output-144" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-26" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#method.mul-26" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#272" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#277" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-146" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#associatedtype.Output-146" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-28" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#method.mul-28" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#277" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-128" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-128" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.mul-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-130" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-130" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.mul-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-132" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-132" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.mul-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-134" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-134" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.mul-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-136" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-136" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.mul-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-138" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-138" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.mul-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#260" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-140" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#associatedtype.Output-140" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#method.mul-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#260" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#266" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-142" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#associatedtype.Output-142" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-24" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#method.mul-24" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#266" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
multiplication
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-119" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-119" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
multiplication
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-120" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-120" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.mul-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-123" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-123" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-125" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-125" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#272" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-143" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-143" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-25" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-25" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#272" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#277" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-145" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-145" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-27" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-27" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#277" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-127" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-127" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-129" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-129" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-131" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-131" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-133" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-133" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-135" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-135" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-137" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-137" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#260" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-139" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-139" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#260" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#266" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-141" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-141" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-23" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-23" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#266" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Mul%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
multiplication
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-118" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-118" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Mul%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
multiplication
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-121" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-121" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.mul-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Mul%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Mul%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
multiplication
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-122" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-122" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul" class="fnname">mul</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.mul-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#222" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html#tymethod.mul">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-MulAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-MulAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#383-384" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self *= rhs</code> as elementwise multiplication (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign" class="fnname">mul_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.mul_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#383-384" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-MulAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-MulAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#383-384" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self *= rhs</code> as elementwise multiplication (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.mul_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign" class="fnname">mul_assign</a>(&mut self, rhs: A)</h4><a href="#method.mul_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#383-384" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>*=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Neg" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a><Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Neg" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#280-293" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.neg" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html#tymethod.neg" class="fnname">neg</a>(self) -> Self</h4><a href="#method.neg" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#287-292" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise negation of <code>self</code> and return the result.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-147" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html#associatedtype.Output" class="type">Output</a> = Self</h4><a href="#associatedtype.Output-147" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Neg-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A: 'a + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a><Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Neg-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#295-306" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.neg-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html#tymethod.neg" class="fnname">neg</a>(self) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.neg-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#303-305" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise negation of reference <code>self</code> and return the
result as a new <code>Array</code>.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-148" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Neg.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-148" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Not" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html" title="trait core::ops::bit::Not">Not</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html" title="trait core::ops::bit::Not">Not</a><Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Not" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#308-321" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.not" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html#tymethod.not" class="fnname">not</a>(self) -> Self</h4><a href="#method.not" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#315-320" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise unary not of <code>self</code> and return the result.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-149" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html#associatedtype.Output" class="type">Output</a> = Self</h4><a href="#associatedtype.Output-149" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>!</code> operator.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Not-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html" title="trait core::ops::bit::Not">Not</a> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>A: 'a + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html" title="trait core::ops::bit::Not">Not</a><Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Not-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#323-334" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.not-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html#tymethod.not" class="fnname">not</a>(self) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.not-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#331-333" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform an elementwise unary not of reference <code>self</code> and return the
result as a new <code>Array</code>.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-150" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Not.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-150" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>!</code> operator.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-PartialEq%3CArrayBase%3CS2%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, S2, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, D>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>>,<br> S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>, </span></h3><a href="#impl-PartialEq%3CArrayBase%3CS2%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#83-107" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Return <code>true</code> if the array shapes and all elements of <code>self</code> and
<code>rhs</code> are equal. Return <code>false</code> otherwise.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.eq" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#tymethod.eq" class="fnname">eq</a>(&self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, D>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.eq" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#89-106" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used
by <code>==</code>. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ne" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#method.ne" class="fnname">ne</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span><a href="#method.ne" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#213" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-41" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-41" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.rem-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-43" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-43" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.rem-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-45" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-45" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.rem-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-47" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-47" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.rem-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-49" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-49" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.rem-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-51" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-51" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.rem-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-53" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-53" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.rem-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-55" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-55" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.rem-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#262" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-57" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#associatedtype.Output-57" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#method.rem-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#262" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#268" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-59" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#associatedtype.Output-59" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-24" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#method.rem-24" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#268" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
remainder
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-36" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-36" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
remainder
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-37" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-37" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.rem-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-40" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-40" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-42" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-42" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-44" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-44" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-46" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-46" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-48" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-48" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-50" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-50" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-52" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-52" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-54" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-54" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#262" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-56" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-56" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#262" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#268" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-58" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-58" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-23" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-23" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#268" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Rem%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
remainder
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-35" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-35" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Rem%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
remainder
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-38" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-38" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.rem-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Rem%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Rem%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
remainder
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-39" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-39" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>%</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem" class="fnname">rem</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.rem-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#224" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html#tymethod.rem">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-RemAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html" title="trait core::ops::arith::RemAssign">RemAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html" title="trait core::ops::arith::RemAssign">RemAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-RemAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#387-388" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self %= rhs</code> as elementwise remainder (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html#tymethod.rem_assign" class="fnname">rem_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.rem_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#387-388" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html#tymethod.rem_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-RemAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html" title="trait core::ops::arith::RemAssign">RemAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html" title="trait core::ops::arith::RemAssign">RemAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-RemAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#387-388" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self %= rhs</code> as elementwise remainder (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.rem_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html#tymethod.rem_assign" class="fnname">rem_assign</a>(&mut self, rhs: A)</h4><a href="#method.rem_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#387-388" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>%=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html#tymethod.rem_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-226" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-226" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.shl-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-228" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-228" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.shl-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-230" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-230" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.shl-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-232" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-232" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.shl-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-234" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-234" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.shl-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-236" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-236" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.shl-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-238" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-238" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.shl-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-240" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-240" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.shl-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
left shift
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-221" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-221" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
left shift
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-222" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-222" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.shl-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-225" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-225" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-227" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-227" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-229" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-229" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-231" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-231" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-233" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-233" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-235" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-235" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-237" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-237" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-239" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-239" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shl%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
left shift
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-220" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-220" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Shl%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
left shift
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-223" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-223" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shl-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shl%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html" title="trait core::ops::bit::Shl">Shl</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Shl%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
left shift
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-224" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-224" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code><<</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl" class="fnname">shl</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.shl-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#228" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shl.html#tymethod.shl">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ShlAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html" title="trait core::ops::bit::ShlAssign">ShlAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html" title="trait core::ops::bit::ShlAssign">ShlAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-ShlAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#395-396" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self <<= rhs</code> as elementwise left shift (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html#tymethod.shl_assign" class="fnname">shl_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.shl_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#395-396" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html#tymethod.shl_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ShlAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html" title="trait core::ops::bit::ShlAssign">ShlAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html" title="trait core::ops::bit::ShlAssign">ShlAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-ShlAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#395-396" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self <<= rhs</code> as elementwise left shift (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shl_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html#tymethod.shl_assign" class="fnname">shl_assign</a>(&mut self, rhs: A)</h4><a href="#method.shl_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#395-396" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code><<=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShlAssign.html#tymethod.shl_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-247" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-247" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.shr-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-249" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-249" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.shr-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-251" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-251" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.shr-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-253" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-253" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.shr-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-255" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-255" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.shr-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-257" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-257" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.shr-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-259" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-259" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.shr-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-261" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-261" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.shr-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
right shift
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-242" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-242" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
right shift
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-243" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-243" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.shr-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-246" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-246" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-248" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-248" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-250" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-250" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-252" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-252" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-254" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-254" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-256" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-256" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-258" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-258" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-260" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-260" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Shr%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
right shift
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-241" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-241" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Shr%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
right shift
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-244" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-244" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.shr-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Shr%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html" title="trait core::ops::bit::Shr">Shr</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Shr%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
right shift
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-245" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-245" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>>></code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr" class="fnname">shr</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.shr-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#229" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>></code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.Shr.html#tymethod.shr">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ShrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html" title="trait core::ops::bit::ShrAssign">ShrAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html" title="trait core::ops::bit::ShrAssign">ShrAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-ShrAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#397-398" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self >>= rhs</code> as elementwise right shift (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html#tymethod.shr_assign" class="fnname">shr_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.shr_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#397-398" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>>=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html#tymethod.shr_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ShrAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html" title="trait core::ops::bit::ShrAssign">ShrAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html" title="trait core::ops::bit::ShrAssign">ShrAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-ShrAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#397-398" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self >>= rhs</code> as elementwise right shift (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.shr_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html#tymethod.shr_assign" class="fnname">shr_assign</a>(&mut self, rhs: A)</h4><a href="#method.shr_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#397-398" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>>>=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/bit/trait.ShrAssign.html#tymethod.shr_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-66" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#associatedtype.Output-66" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-6" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>, D></h4><a href="#method.sub-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-68" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#associatedtype.Output-68" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-8" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>, D></h4><a href="#method.sub-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#271" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-86" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#associatedtype.Output-86" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-26" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>, D></h4><a href="#method.sub-26" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#271" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#276" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-88" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#associatedtype.Output-88" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-28" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>, D></h4><a href="#method.sub-28" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#276" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-70" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#associatedtype.Output-70" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-10" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>, D></h4><a href="#method.sub-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-72" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#associatedtype.Output-72" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-12" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>, D></h4><a href="#method.sub-12" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-74" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#associatedtype.Output-74" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-14" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>, D></h4><a href="#method.sub-14" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-76" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#associatedtype.Output-76" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-16" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>, D></h4><a href="#method.sub-16" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-78" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#associatedtype.Output-78" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-18" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>, D></h4><a href="#method.sub-18" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-80" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#associatedtype.Output-80" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-20" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>, D></h4><a href="#method.sub-20" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#259" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-82" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#associatedtype.Output-82" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-22" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>, D></h4><a href="#method.sub-22" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#259" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#265" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-84" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#associatedtype.Output-84" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-24" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>, D></h4><a href="#method.sub-24" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#265" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
subtraction
between <code>self</code> and reference <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-61" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-61" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, 'b, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for &'b <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><A, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
subtraction
between references <code>self</code> and <code>rhs</code>,
and return the result as a new <code>Array</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-62" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-62" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-2" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.sub-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i8.html">i8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-65" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-65" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-5" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#245" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u8.html">u8</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-67" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-67" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-7" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#246" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-10" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-10" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#271" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-85" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-85" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-25" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-25" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#271" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-11" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="struct" href="../num_complex/struct.Complex.html" title="struct num_complex::Complex">Complex</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#276" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-87" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-87" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-27" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-27" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#276" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-2" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i16.html">i16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-2" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-69" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-69" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-9" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#247" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-3" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u16.html">u16</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-71" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-71" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-11" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-11" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#248" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-4" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i32.html">i32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-73" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-73" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-13" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-13" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#249" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-5" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u32.html">u32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-5" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-75" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-75" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-15" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-15" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#250" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-6" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.i64.html">i64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-6" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-77" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-77" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-17" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-17" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#251" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-7" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.u64.html">u64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-7" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-79" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-79" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-19" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-19" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#252" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-8" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f32.html">f32</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-8" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#259" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-81" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-81" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-21" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-21" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#259" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-9" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>> for <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.f64.html">f64</a>> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS%2C%20D%3E%3E-9" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#265" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-83" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-83" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-23" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-23" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#265" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><A, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-Sub%3CArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
subtraction
between <code>self</code> and <code>rhs</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
<p>If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-60" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-60" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, rhs: <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CB%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><B> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><B, Output = A>,<br> S: <a class="trait" href="trait.DataOwned.html" title="trait ndarray::DataOwned">DataOwned</a><Elem = A> + <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Sub%3CB%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
subtraction
between <code>self</code> and the scalar <code>x</code>,
and return the result (based on <code>self</code>).</p>
<p><code>self</code> must be an <code>Array</code> or <code>RcArray</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-63" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#associatedtype.Output-63" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, x: B) -> <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h4><a href="#method.sub-3" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sub%3CB%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, D, B> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><B> for &'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><B, Output = A>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> B: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a>, </span></h3><a href="#impl-Sub%3CB%3E-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform elementwise
subtraction
between the reference <code>self</code> and the scalar <code>x</code>,
and return the result as a new <code>Array</code>.</p>
</div><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output-64" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#associatedtype.Output" class="type">Output</a> = <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#associatedtype.Output-64" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub-4" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub" class="fnname">sub</a>(self, x: B) -> <a class="type" href="type.Array.html" title="type ndarray::Array">Array</a><A, D></h4><a href="#method.sub-4" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#221" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html#tymethod.sub">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-SubAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A, S, S2, D, E> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><&'a <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> S2: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> E: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-SubAssign%3C%26%27a%20ArrayBase%3CS2%2C%20E%3E%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#381-382" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self -= rhs</code> as elementwise subtraction (in place).
If their shapes disagree, <code>rhs</code> is broadcast to the shape of <code>self</code>.</p>
<p><strong>Panics</strong> if broadcasting isn’t possible.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub_assign" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign" class="fnname">sub_assign</a>(&mut self, rhs: &<a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S2, E>)</h4><a href="#method.sub_assign" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#381-382" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-SubAssign%3CA%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><A> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> A: <a class="trait" href="trait.ScalarOperand.html" title="trait ndarray::ScalarOperand">ScalarOperand</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><A>,<br> S: <a class="trait" href="trait.DataMut.html" title="trait ndarray::DataMut">DataMut</a><Elem = A>,<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>, </span></h3><a href="#impl-SubAssign%3CA%3E" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#381-382" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Perform <code>self -= rhs</code> as elementwise subtraction (in place).</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sub_assign-1" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign" class="fnname">sub_assign</a>(&mut self, rhs: A)</h4><a href="#method.sub_assign-1" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_ops.rs.html#381-382" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the <code>-=</code> operation. <a href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-UpperExp" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, A: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.UpperExp.html" title="trait core::fmt::UpperExp">UpperExp</a>, S, D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.UpperExp.html" title="trait core::fmt::UpperExp">UpperExp</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a><Elem = A>, </span></h3><a href="#impl-UpperExp" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#131-137" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Format the array using <code>UpperExp</code> and apply the formatting parameters used
to each element.</p>
<p>The array is shown in multiline style.</p>
</div><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt-3" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.UpperExp.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.54.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4><a href="#method.fmt-3" class="anchor"></a><a class="srclink" href="../src/ndarray/arrayformat.rs.html#134-136" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><div id="impl-Copy" class="impl has-srclink"><h3 class="code-header in-band">impl<S: <a class="trait" href="trait.DataClone.html" title="trait ndarray::DataClone">DataClone</a> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>, D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D></h3><a href="#impl-Copy" class="anchor"></a><a class="srclink" href="../src/ndarray/impl_clone.rs.html#36" title="goto source code">[src]</a></div><div id="impl-Eq" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="trait.Dimension.html" title="trait ndarray::Dimension">Dimension</a>,<br> S: <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>,<br> S::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></h3><a href="#impl-Eq" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#109-113" title="goto source code">[src]</a></div><div id="impl-Send" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>,<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>, </span></h3><a href="#impl-Send" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#206-208" title="goto source code">[src]</a></div><div class="docblock"><p><code>ArrayBase</code> is <code>Send</code> when the storage type is.</p>
</div><div id="impl-Sync" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> + <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>,<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>, </span></h3><a href="#impl-Sync" class="anchor"></a><a class="srclink" href="../src/ndarray/arraytraits.rs.html#201-203" title="goto source code">[src]</a></div><div class="docblock"><p><code>ArrayBase</code> is <code>Sync</code> when the storage type is.</p>
</div></div><h2 id="synthetic-implementations" class="small-section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor"></a></h2><div id="synthetic-implementations-list"><div id="impl-RefUnwindSafe" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>,<br> <S as <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>>::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>, </span></h3><a href="#impl-RefUnwindSafe" class="anchor"></a></div><div id="impl-Unpin" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>, </span></h3><a href="#impl-Unpin" class="anchor"></a></div><div id="impl-UnwindSafe" class="impl has-srclink"><h3 class="code-header in-band">impl<S, D> <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.ArrayBase.html" title="struct ndarray::ArrayBase">ArrayBase</a><S, D> <span class="where fmt-newline">where<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>,<br> <S as <a class="trait" href="trait.Data.html" title="trait ndarray::Data">Data</a>>::<a class="type" href="trait.Data.html#associatedtype.Elem" title="type ndarray::Data::Elem">Elem</a>: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>, </span></h3><a href="#impl-UnwindSafe" class="anchor"></a></div></div><h2 id="blanket-implementations" class="small-section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor"></a></h2><div id="blanket-implementations-list"><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Any" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-Any" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/any.rs.html#131-135" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.type_id" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html#tymethod.type_id" class="fnname">type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4><a href="#method.type_id" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/any.rs.html#132" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Borrow%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-Borrow%3CT%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#208-213" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>T</h4><a href="#method.borrow" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#210" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BorrowMut%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-BorrowMut%3CT%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#216-220" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow_mut" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fnname">borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T</h4><a href="#method.borrow_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#217" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</h3><a href="#impl-From%3CT%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#544-548" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-2" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: T) -> T</h4><a href="#method.from-2" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#545" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Into%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>, </span></h3><a href="#impl-Into%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#533-540" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html#tymethod.into" class="fnname">into</a>(self) -> U</h4><a href="#method.into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#537" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ToOwned" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3><a href="#impl-ToOwned" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#84-96" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Owned" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="type">Owned</a> = T</h4><a href="#associatedtype.Owned" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after obtaining ownership.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_owned-1" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fnname">to_owned</a>(&self) -> T</h4><a href="#method.to_owned-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#89" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone_into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fnname">clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T)</h4><a href="#method.clone_into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#93" title="goto source code">[src]</a></div></summary><div class="item-info"><div class="stab unstable"><details><summary><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</summary><p>recently added</p>
</details></div></div><div class='docblock'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ToString" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/alloc/string/trait.ToString.html" title="trait alloc::string::ToString">ToString</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> + ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-ToString" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/string.rs.html#2372-2386" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_string" class="method trait-impl has-srclink"><h4 class="code-header">pub default fn <a href="https://doc.rust-lang.org/1.54.0/alloc/string/trait.ToString.html#tymethod.to_string" class="fnname">to_string</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/alloc/string/struct.String.html" title="struct alloc::string::String">String</a></h4><a href="#method.to_string" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/string.rs.html#2378" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Converts the given value to a <code>String</code>. <a href="https://doc.rust-lang.org/1.54.0/alloc/string/trait.ToString.html#tymethod.to_string">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-TryFrom%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>, </span></h3><a href="#impl-TryFrom%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#581-590" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4><a href="#associatedtype.Error" class="anchor"></a></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_from" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4><a href="#method.try_from" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#587" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-TryInto%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>, </span></h3><a href="#impl-TryInto%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#567-576" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html#associatedtype.Error" class="type">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4><a href="#associatedtype.Error-1" class="anchor"></a></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fnname">try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4><a href="#method.try_into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#573" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><div id="impl-NumAssignOps%3CRhs%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, Rhs> <a class="trait" href="../num_traits/trait.NumAssignOps.html" title="trait num_traits::NumAssignOps">NumAssignOps</a><Rhs> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><Rhs> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><Rhs> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><Rhs> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><Rhs> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.RemAssign.html" title="trait core::ops::arith::RemAssign">RemAssign</a><Rhs>, </span></h3><a href="#impl-NumAssignOps%3CRhs%3E" class="anchor"></a><a class="srclink" href="../src/num_traits/lib.rs.html#141-144" title="goto source code">[src]</a></div><div id="impl-NumOps%3CRhs%2C%20Output%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, Rhs, Output> <a class="trait" href="../num_traits/trait.NumOps.html" title="trait num_traits::NumOps">NumOps</a><Rhs, Output> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><Rhs, Output = Output> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><Rhs, Output = Output> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><Rhs, Output = Output> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><Rhs, Output = Output> + <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/arith/trait.Rem.html" title="trait core::ops::arith::Rem">Rem</a><Rhs, Output = Output>, </span></h3><a href="#impl-NumOps%3CRhs%2C%20Output%3E" class="anchor"></a><a class="srclink" href="../src/num_traits/lib.rs.html#110-117" title="goto source code">[src]</a></div><div id="impl-RefNum%3CBase%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, Base> <a class="trait" href="../num_traits/trait.RefNum.html" title="trait num_traits::RefNum">RefNum</a><Base> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="../num_traits/trait.NumOps.html" title="trait num_traits::NumOps">NumOps</a><Base, Base> + for<'r> <a class="trait" href="../num_traits/trait.NumOps.html" title="trait num_traits::NumOps">NumOps</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'r </a>Base, Base>, </span></h3><a href="#impl-RefNum%3CBase%3E" class="anchor"></a><a class="srclink" href="../src/num_traits/lib.rs.html#131" title="goto source code">[src]</a></div></div></section><section id="search" class="content hidden"></section><div id="rustdoc-vars" data-root-path="../" data-current-crate="ndarray" data-search-index-js="../search-index.js" data-search-js="../search.js"></div><script src="../main.js"></script></body></html>