diff --git a/docs_sphinx/_build/doctrees/developer/units.doctree b/docs_sphinx/_build/doctrees/developer/units.doctree
index 006b338..96b40e5 100644
Binary files a/docs_sphinx/_build/doctrees/developer/units.doctree and b/docs_sphinx/_build/doctrees/developer/units.doctree differ
diff --git a/docs_sphinx/_build/doctrees/environment.pickle b/docs_sphinx/_build/doctrees/environment.pickle
index f64ede3..ff93153 100644
Binary files a/docs_sphinx/_build/doctrees/environment.pickle and b/docs_sphinx/_build/doctrees/environment.pickle differ
diff --git a/docs_sphinx/_build/doctrees/index.doctree b/docs_sphinx/_build/doctrees/index.doctree
index 7cede8b..3e8b2da 100644
Binary files a/docs_sphinx/_build/doctrees/index.doctree and b/docs_sphinx/_build/doctrees/index.doctree differ
diff --git a/docs_sphinx/_build/doctrees/modules.doctree b/docs_sphinx/_build/doctrees/modules.doctree
index 159ff9a..aee88c4 100644
Binary files a/docs_sphinx/_build/doctrees/modules.doctree and b/docs_sphinx/_build/doctrees/modules.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.allunits.doctree b/docs_sphinx/_build/doctrees/unitSI.allunits.doctree
index a7760e0..949e4fb 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.allunits.doctree and b/docs_sphinx/_build/doctrees/unitSI.allunits.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.constants.doctree b/docs_sphinx/_build/doctrees/unitSI.constants.doctree
index 8ead66a..908ed50 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.constants.doctree and b/docs_sphinx/_build/doctrees/unitSI.constants.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.doctree b/docs_sphinx/_build/doctrees/unitSI.doctree
index 010ff57..70dd41f 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.doctree and b/docs_sphinx/_build/doctrees/unitSI.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.fundamentalunits.doctree b/docs_sphinx/_build/doctrees/unitSI.fundamentalunits.doctree
index ef6834e..a7f577e 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.fundamentalunits.doctree and b/docs_sphinx/_build/doctrees/unitSI.fundamentalunits.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.stdunits.doctree b/docs_sphinx/_build/doctrees/unitSI.stdunits.doctree
index 27e8161..ca87904 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.stdunits.doctree and b/docs_sphinx/_build/doctrees/unitSI.stdunits.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.tests.doctree b/docs_sphinx/_build/doctrees/unitSI.tests.doctree
index 5409183..0391f12 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.tests.doctree and b/docs_sphinx/_build/doctrees/unitSI.tests.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.tests.test_units.doctree b/docs_sphinx/_build/doctrees/unitSI.tests.test_units.doctree
index 48f4e65..e771074 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.tests.test_units.doctree and b/docs_sphinx/_build/doctrees/unitSI.tests.test_units.doctree differ
diff --git a/docs_sphinx/_build/doctrees/unitSI.unitsafefunctions.doctree b/docs_sphinx/_build/doctrees/unitSI.unitsafefunctions.doctree
index 2315dc6..97a3418 100644
Binary files a/docs_sphinx/_build/doctrees/unitSI.unitsafefunctions.doctree and b/docs_sphinx/_build/doctrees/unitSI.unitsafefunctions.doctree differ
diff --git a/docs_sphinx/_build/doctrees/user/units.doctree b/docs_sphinx/_build/doctrees/user/units.doctree
index 433cb89..a882d44 100644
Binary files a/docs_sphinx/_build/doctrees/user/units.doctree and b/docs_sphinx/_build/doctrees/user/units.doctree differ
diff --git a/docs_sphinx/_build/html/.buildinfo b/docs_sphinx/_build/html/.buildinfo
index 7f4b391..31d211d 100644
--- a/docs_sphinx/_build/html/.buildinfo
+++ b/docs_sphinx/_build/html/.buildinfo
@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 4374b0e176374bbade8fc0741aa57c26
+config: 33d4bf14955ac538f4fa8aa5e2d74e59
 tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/docs_sphinx/_build/html/_modules/index.html b/docs_sphinx/_build/html/_modules/index.html
index 452223c..710af69 100644
--- a/docs_sphinx/_build/html/_modules/index.html
+++ b/docs_sphinx/_build/html/_modules/index.html
@@ -43,6 +43,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="../user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../modules.html">unitSI</a></li>
 </ul>
 
diff --git a/docs_sphinx/_build/html/_modules/unitSI/fundamentalunits.html b/docs_sphinx/_build/html/_modules/unitSI/fundamentalunits.html
index cfa20e4..21bc045 100644
--- a/docs_sphinx/_build/html/_modules/unitSI/fundamentalunits.html
+++ b/docs_sphinx/_build/html/_modules/unitSI/fundamentalunits.html
@@ -1,34 +1,77 @@
 <!DOCTYPE html>
-
-<html lang="en" data-content_root="../../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>unitSI.fundamentalunits &#8212; unitSI v1.0 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=61cd365c" />
-    <link rel="stylesheet" type="text/css" href="../../_static/alabaster.css?v=12dfc556" />
-    <script src="../../_static/documentation_options.js?v=e160b93e"></script>
-    <script src="../../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../../genindex.html" />
-    <link rel="search" title="Search" href="../../search.html" />
-   
-  <link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
-  
+<html class="writer-html5" lang="en" data-content_root="../../">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>unitSI.fundamentalunits &mdash; unitSI v1.0 documentation</title>
+      <link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=92fd9be5" />
+      <link rel="stylesheet" type="text/css" href="../../_static/css/theme.css?v=19f00094" />
 
   
+  <!--[if lt IE 9]>
+    <script src="../../_static/js/html5shiv.min.js"></script>
+  <![endif]-->
   
+        <script src="../../_static/jquery.js?v=5d32c60e"></script>
+        <script src="../../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
+        <script src="../../_static/documentation_options.js?v=e160b93e"></script>
+        <script src="../../_static/doctools.js?v=9a2dae69"></script>
+        <script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
+    <script src="../../_static/js/theme.js"></script>
+    <link rel="index" title="Index" href="../../genindex.html" />
+    <link rel="search" title="Search" href="../../search.html" /> 
+</head>
 
-  </head><body>
-  
+<body class="wy-body-for-nav"> 
+  <div class="wy-grid-for-nav">
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
 
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
           
+          
+          <a href="../../index.html" class="icon icon-home">
+            unitSI
+          </a>
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+        </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
+              <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="../../user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../developer/units.html">Units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../modules.html">unitSI</a></li>
+</ul>
 
-          <div class="body" role="main">
-            
+        </div>
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="../../index.html">unitSI</a>
+      </nav>
+
+      <div class="wy-nav-content">
+        <div class="rst-content">
+          <div role="navigation" aria-label="Page navigation">
+  <ul class="wy-breadcrumbs">
+      <li><a href="../../index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="../index.html">Module code</a></li>
+      <li class="breadcrumb-item active">unitSI.fundamentalunits</li>
+      <li class="wy-breadcrumbs-aside">
+      </li>
+  </ul>
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+             
   <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 <span></span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">Defines physical units and quantities</span>
@@ -670,7 +713,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="get_or_create_dimension">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.get_or_create_dimension">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_or_create_dimension">[docs]</a>
 <span class="k">def</span> <span class="nf">get_or_create_dimension</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Create a new Dimension object or get a reference to an existing one.</span>
@@ -736,7 +779,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="DimensionMismatchError">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.DimensionMismatchError">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.DimensionMismatchError">[docs]</a>
 <span class="k">class</span> <span class="nc">DimensionMismatchError</span><span class="p">(</span><span class="ne">Exception</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Exception class for attempted operations with inconsistent dimensions.</span>
@@ -790,7 +833,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="is_scalar_type">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.is_scalar_type">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_scalar_type">[docs]</a>
 <span class="k">def</span> <span class="nf">is_scalar_type</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Tells you if the object is a 1d number type.</span>
@@ -814,7 +857,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="get_dimensions">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.get_dimensions">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_dimensions">[docs]</a>
 <span class="k">def</span> <span class="nf">get_dimensions</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Return the dimensions of any object that has them.</span>
@@ -858,7 +901,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="is_dimensionless">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.is_dimensionless">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_dimensionless">[docs]</a>
 <span class="k">def</span> <span class="nf">is_dimensionless</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Test if a value is dimensionless or not.</span>
@@ -878,7 +921,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="have_same_dimensions">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.have_same_dimensions">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.have_same_dimensions">[docs]</a>
 <span class="k">def</span> <span class="nf">have_same_dimensions</span><span class="p">(</span><span class="n">obj1</span><span class="p">,</span> <span class="n">obj2</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;Test if two values have the same dimensions.</span>
 
@@ -909,7 +952,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="in_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.in_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_unit">[docs]</a>
 <span class="k">def</span> <span class="nf">in_unit</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">precision</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Display a value in a certain unit with a given precision.</span>
@@ -960,7 +1003,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="in_best_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.in_best_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_best_unit">[docs]</a>
 <span class="k">def</span> <span class="nf">in_best_unit</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">precision</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Represent the value in the &quot;best&quot; unit.</span>
@@ -1038,7 +1081,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Quantity">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity">[docs]</a>
 <span class="k">class</span> <span class="nc">Quantity</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    A number with an associated physical dimension. In most cases, it is not</span>
@@ -1316,7 +1359,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="c1"># Quantity-specific functions (not existing in ndarray)</span>
     <span class="c1"># ==============================================================================</span>
 <div class="viewcode-block" id="Quantity.with_dimensions">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.with_dimensions">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.with_dimensions">[docs]</a>
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">with_dimensions</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">keywords</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
@@ -1375,7 +1418,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="c1">#### METHODS ####</span>
 
 <div class="viewcode-block" id="Quantity.has_same_dimensions">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.has_same_dimensions">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.has_same_dimensions">[docs]</a>
     <span class="k">def</span> <span class="nf">has_same_dimensions</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Return whether this object has the same dimensions as another.</span>
@@ -1398,7 +1441,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Quantity.in_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.in_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.in_unit">[docs]</a>
     <span class="k">def</span> <span class="nf">in_unit</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">precision</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">python_code</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Represent the quantity in a given unit. If `python_code` is ``True``,</span>
@@ -1470,7 +1513,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Quantity.get_best_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.get_best_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.get_best_unit">[docs]</a>
     <span class="k">def</span> <span class="nf">get_best_unit</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">regs</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Return the best unit for this `Quantity`.</span>
@@ -1509,7 +1552,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">get_best_unit</span><span class="p">(</span><span class="o">*</span><span class="n">regs</span><span class="p">)</span>
 
 <div class="viewcode-block" id="Quantity.in_best_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.in_best_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.in_best_unit">[docs]</a>
     <span class="k">def</span> <span class="nf">in_best_unit</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">precision</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">python_code</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span> <span class="o">*</span><span class="n">regs</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Represent the quantity in the &quot;best&quot; unit.</span>
@@ -1566,7 +1609,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">Quantity</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="o">.</span><span class="fm">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">dim</span><span class="p">)</span>
 
 <div class="viewcode-block" id="Quantity.item">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.item">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.item">[docs]</a>
     <span class="k">def</span> <span class="nf">item</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;Overwritten to assure that the returned element retains its unit.&quot;&quot;&quot;</span>
         <span class="k">return</span> <span class="n">Quantity</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="o">.</span><span class="n">item</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">dim</span><span class="p">)</span></div>
@@ -1577,7 +1620,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__setitem__</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
 
 <div class="viewcode-block" id="Quantity.tolist">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.tolist">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.tolist">[docs]</a>
     <span class="k">def</span> <span class="nf">tolist</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Convert the array into a list.</span>
@@ -1754,7 +1797,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="k">if</span> <span class="n">use_matplotlib_units_fix</span><span class="p">:</span>
 
 <div class="viewcode-block" id="Quantity.ravel">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.ravel">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.ravel">[docs]</a>
         <span class="k">def</span> <span class="nf">ravel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>
             <span class="c1"># Note that we don&#39;t use Brian&#39;s logging system here as we don&#39;t want</span>
             <span class="c1"># the unit system to depend on other parts of Brian</span>
@@ -1789,7 +1832,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">argsort</span> <span class="o">=</span> <span class="n">wrap_function_remove_dimensions</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="o">.</span><span class="n">argsort</span><span class="p">)</span>
 
 <div class="viewcode-block" id="Quantity.fill">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.fill">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.fill">[docs]</a>
     <span class="k">def</span> <span class="nf">fill</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">,</span> <span class="s2">&quot;fill&quot;</span><span class="p">)</span>
         <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="n">values</span><span class="p">)</span></div>
@@ -1799,7 +1842,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">fill</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.put">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.put">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.put">[docs]</a>
     <span class="k">def</span> <span class="nf">put</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">indices</span><span class="p">,</span> <span class="n">values</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">,</span> <span class="s2">&quot;fill&quot;</span><span class="p">)</span>
         <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">put</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">values</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span></div>
@@ -1809,7 +1852,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">put</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.clip">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.clip">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.clip">[docs]</a>
     <span class="k">def</span> <span class="nf">clip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a_min</span><span class="p">,</span> <span class="n">a_max</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a_min</span><span class="p">,</span> <span class="s2">&quot;clip&quot;</span><span class="p">)</span>
         <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a_max</span><span class="p">,</span> <span class="s2">&quot;clip&quot;</span><span class="p">)</span>
@@ -1829,7 +1872,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">clip</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.dot">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.dot">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.dot">[docs]</a>
     <span class="k">def</span> <span class="nf">dot</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="k">return</span> <span class="n">Quantity</span><span class="p">(</span>
             <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="n">other</span><span class="p">),</span> <span class="o">**</span><span class="n">kwds</span><span class="p">),</span>
@@ -1841,7 +1884,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">dot</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.searchsorted">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.searchsorted">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.searchsorted">[docs]</a>
     <span class="k">def</span> <span class="nf">searchsorted</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="s2">&quot;searchsorted&quot;</span><span class="p">)</span>
         <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">searchsorted</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">asarray</span><span class="p">(</span><span class="n">v</span><span class="p">),</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span></div>
@@ -1851,7 +1894,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">searchsorted</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.prod">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.prod">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.prod">[docs]</a>
     <span class="k">def</span> <span class="nf">prod</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="n">prod_result</span> <span class="o">=</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">prod</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span>
         <span class="c1"># Calculating the correct dimensions is not completly trivial (e.g.</span>
@@ -1874,7 +1917,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
     <span class="n">prod</span><span class="o">.</span><span class="n">_do_not_run_doctests</span> <span class="o">=</span> <span class="kc">True</span>
 
 <div class="viewcode-block" id="Quantity.cumprod">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Quantity.cumprod">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.cumprod">[docs]</a>
     <span class="k">def</span> <span class="nf">cumprod</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
         <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_dimensionless</span><span class="p">:</span>
             <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
@@ -1890,7 +1933,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit">[docs]</a>
 <span class="k">class</span> <span class="nc">Unit</span><span class="p">(</span><span class="n">Quantity</span><span class="p">):</span>
 <span class="w">    </span><span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">     A physical unit.</span>
@@ -2065,7 +2108,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
             <span class="n">register_new_unit</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
 
 <div class="viewcode-block" id="Unit.create">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit.create">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.create">[docs]</a>
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">create</span><span class="p">(</span><span class="n">dim</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">dispname</span><span class="p">,</span> <span class="n">latexname</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
@@ -2110,7 +2153,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Unit.create_scaled_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit.create_scaled_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.create_scaled_unit">[docs]</a>
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">create_scaled_unit</span><span class="p">(</span><span class="n">baseunit</span><span class="p">,</span> <span class="n">scalefactor</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;</span>
@@ -2150,7 +2193,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
     <span class="c1">#### METHODS ####</span>
 <div class="viewcode-block" id="Unit.set_name">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit.set_name">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_name">[docs]</a>
     <span class="k">def</span> <span class="nf">set_name</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;Sets the name for the unit.</span>
 
@@ -2165,7 +2208,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Unit.set_display_name">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit.set_display_name">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_display_name">[docs]</a>
     <span class="k">def</span> <span class="nf">set_display_name</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;Sets the display name for the unit.</span>
 
@@ -2180,7 +2223,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="Unit.set_latex_name">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.Unit.set_latex_name">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_latex_name">[docs]</a>
     <span class="k">def</span> <span class="nf">set_latex_name</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
 <span class="w">        </span><span class="sd">&quot;&quot;&quot;Sets the LaTeX name for the unit.</span>
 
@@ -2509,7 +2552,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="register_new_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.register_new_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.register_new_unit">[docs]</a>
 <span class="k">def</span> <span class="nf">register_new_unit</span><span class="p">(</span><span class="n">u</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;Register a new unit for automatic displaying of quantities</span>
 
@@ -2540,7 +2583,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="get_unit">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.get_unit">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_unit">[docs]</a>
 <span class="k">def</span> <span class="nf">get_unit</span><span class="p">(</span><span class="n">d</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Find an unscaled unit (e.g. `volt` but not `mvolt`) for a `Dimension`.</span>
@@ -2592,7 +2635,7 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="check_units">
-<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.check_units">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.fundamentalunits.html#unitSI.fundamentalunits.check_units">[docs]</a>
 <span class="k">def</span> <span class="nf">check_units</span><span class="p">(</span><span class="o">**</span><span class="n">au</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;Decorator to check units of arguments passed to a function</span>
 
@@ -2847,69 +2890,31 @@ <h1>Source code for unitSI.fundamentalunits</h1><div class="highlight"><pre>
 
 </pre></div>
 
+           </div>
           </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../../index.html">unitSI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-<p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="../../modules.html">unitSI</a></li>
-</ul>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../../index.html">Documentation overview</a><ul>
-  <li><a href="../index.html">Module code</a><ul>
-  </ul></li>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
+          <footer>
 
+  <hr/>
 
+  <div role="contentinfo">
+    <p>&#169; Copyright 2024, Sorin Birchi.</p>
+  </div>
 
+  Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
+    <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+   
 
+</footer>
         </div>
       </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Sorin Birchi.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
+    </section>
+  </div>
+  <script>
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script> 
+
+</body>
 </html>
\ No newline at end of file
diff --git a/docs_sphinx/_build/html/_modules/unitSI/tests/test_units.html b/docs_sphinx/_build/html/_modules/unitSI/tests/test_units.html
index 8b53607..b5670d5 100644
--- a/docs_sphinx/_build/html/_modules/unitSI/tests/test_units.html
+++ b/docs_sphinx/_build/html/_modules/unitSI/tests/test_units.html
@@ -1,34 +1,77 @@
 <!DOCTYPE html>
-
-<html lang="en" data-content_root="../../../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>unitSI.tests.test_units &#8212; unitSI v1.0 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css?v=61cd365c" />
-    <link rel="stylesheet" type="text/css" href="../../../_static/alabaster.css?v=12dfc556" />
-    <script src="../../../_static/documentation_options.js?v=e160b93e"></script>
-    <script src="../../../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../../../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../../../genindex.html" />
-    <link rel="search" title="Search" href="../../../search.html" />
-   
-  <link rel="stylesheet" href="../../../_static/custom.css" type="text/css" />
-  
+<html class="writer-html5" lang="en" data-content_root="../../../">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>unitSI.tests.test_units &mdash; unitSI v1.0 documentation</title>
+      <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css?v=92fd9be5" />
+      <link rel="stylesheet" type="text/css" href="../../../_static/css/theme.css?v=19f00094" />
 
   
+  <!--[if lt IE 9]>
+    <script src="../../../_static/js/html5shiv.min.js"></script>
+  <![endif]-->
   
+        <script src="../../../_static/jquery.js?v=5d32c60e"></script>
+        <script src="../../../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
+        <script src="../../../_static/documentation_options.js?v=e160b93e"></script>
+        <script src="../../../_static/doctools.js?v=9a2dae69"></script>
+        <script src="../../../_static/sphinx_highlight.js?v=dc90522c"></script>
+    <script src="../../../_static/js/theme.js"></script>
+    <link rel="index" title="Index" href="../../../genindex.html" />
+    <link rel="search" title="Search" href="../../../search.html" /> 
+</head>
 
-  </head><body>
-  
+<body class="wy-body-for-nav"> 
+  <div class="wy-grid-for-nav">
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
 
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
           
+          
+          <a href="../../../index.html" class="icon icon-home">
+            unitSI
+          </a>
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="../../../search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+        </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
+              <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="../../../user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../../developer/units.html">Units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../../modules.html">unitSI</a></li>
+</ul>
 
-          <div class="body" role="main">
-            
+        </div>
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="../../../index.html">unitSI</a>
+      </nav>
+
+      <div class="wy-nav-content">
+        <div class="rst-content">
+          <div role="navigation" aria-label="Page navigation">
+  <ul class="wy-breadcrumbs">
+      <li><a href="../../../index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="../../index.html">Module code</a></li>
+      <li class="breadcrumb-item active">unitSI.tests.test_units</li>
+      <li class="wy-breadcrumbs-aside">
+      </li>
+  </ul>
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+             
   <h1>Source code for unitSI.tests.test_units</h1><div class="highlight"><pre>
 <span></span><span class="kn">import</span> <span class="nn">itertools</span>
 <span class="kn">import</span> <span class="nn">pickle</span>
@@ -1718,69 +1761,31 @@ <h1>Source code for unitSI.tests.test_units</h1><div class="highlight"><pre>
     <span class="n">test_constants</span><span class="p">()</span>
 </pre></div>
 
+           </div>
           </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../../../index.html">unitSI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-<p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="../../../modules.html">unitSI</a></li>
-</ul>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../../../index.html">Documentation overview</a><ul>
-  <li><a href="../../index.html">Module code</a><ul>
-  </ul></li>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../../../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
+          <footer>
 
+  <hr/>
 
+  <div role="contentinfo">
+    <p>&#169; Copyright 2024, Sorin Birchi.</p>
+  </div>
 
+  Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
+    <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+   
 
+</footer>
         </div>
       </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Sorin Birchi.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
+    </section>
+  </div>
+  <script>
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script> 
+
+</body>
 </html>
\ No newline at end of file
diff --git a/docs_sphinx/_build/html/_modules/unitSI/unitsafefunctions.html b/docs_sphinx/_build/html/_modules/unitSI/unitsafefunctions.html
index 181e53d..478069a 100644
--- a/docs_sphinx/_build/html/_modules/unitSI/unitsafefunctions.html
+++ b/docs_sphinx/_build/html/_modules/unitSI/unitsafefunctions.html
@@ -1,34 +1,77 @@
 <!DOCTYPE html>
-
-<html lang="en" data-content_root="../../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>unitSI.unitsafefunctions &#8212; unitSI v1.0 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=61cd365c" />
-    <link rel="stylesheet" type="text/css" href="../../_static/alabaster.css?v=12dfc556" />
-    <script src="../../_static/documentation_options.js?v=e160b93e"></script>
-    <script src="../../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../../genindex.html" />
-    <link rel="search" title="Search" href="../../search.html" />
-   
-  <link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
-  
+<html class="writer-html5" lang="en" data-content_root="../../">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>unitSI.unitsafefunctions &mdash; unitSI v1.0 documentation</title>
+      <link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=92fd9be5" />
+      <link rel="stylesheet" type="text/css" href="../../_static/css/theme.css?v=19f00094" />
 
   
+  <!--[if lt IE 9]>
+    <script src="../../_static/js/html5shiv.min.js"></script>
+  <![endif]-->
   
+        <script src="../../_static/jquery.js?v=5d32c60e"></script>
+        <script src="../../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
+        <script src="../../_static/documentation_options.js?v=e160b93e"></script>
+        <script src="../../_static/doctools.js?v=9a2dae69"></script>
+        <script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
+    <script src="../../_static/js/theme.js"></script>
+    <link rel="index" title="Index" href="../../genindex.html" />
+    <link rel="search" title="Search" href="../../search.html" /> 
+</head>
 
-  </head><body>
-  
+<body class="wy-body-for-nav"> 
+  <div class="wy-grid-for-nav">
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
 
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
           
+          
+          <a href="../../index.html" class="icon icon-home">
+            unitSI
+          </a>
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+        </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
+              <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="../../user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../developer/units.html">Units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../modules.html">unitSI</a></li>
+</ul>
 
-          <div class="body" role="main">
-            
+        </div>
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="../../index.html">unitSI</a>
+      </nav>
+
+      <div class="wy-nav-content">
+        <div class="rst-content">
+          <div role="navigation" aria-label="Page navigation">
+  <ul class="wy-breadcrumbs">
+      <li><a href="../../index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="../index.html">Module code</a></li>
+      <li class="breadcrumb-item active">unitSI.unitsafefunctions</li>
+      <li class="wy-breadcrumbs-aside">
+      </li>
+  </ul>
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+             
   <h1>Source code for unitSI.unitsafefunctions</h1><div class="highlight"><pre>
 <span></span><span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">Unit-aware replacements for numpy functions.</span>
@@ -82,7 +125,7 @@ <h1>Source code for unitSI.unitsafefunctions</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="where">
-<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.where">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.where">[docs]</a>
 <span class="k">def</span> <span class="nf">where</span><span class="p">(</span><span class="n">condition</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>  <span class="c1"># pylint: disable=C0111</span>
     <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
         <span class="c1"># nothing to do</span>
@@ -184,7 +227,7 @@ <h1>Source code for unitSI.unitsafefunctions</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="arange">
-<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.arange">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arange">[docs]</a>
 <span class="nd">@wraps</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">)</span>
 <span class="k">def</span> <span class="nf">arange</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
     <span class="c1"># arange has a bit of a complicated argument structure unfortunately</span>
@@ -264,7 +307,7 @@ <h1>Source code for unitSI.unitsafefunctions</h1><div class="highlight"><pre>
 
 
 <div class="viewcode-block" id="linspace">
-<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.linspace">[docs]</a>
+<a class="viewcode-back" href="../../unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.linspace">[docs]</a>
 <span class="nd">@wraps</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">)</span>
 <span class="k">def</span> <span class="nf">linspace</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="mi">50</span><span class="p">,</span> <span class="n">endpoint</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">retstep</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
     <span class="n">fail_for_dimension_mismatch</span><span class="p">(</span>
@@ -323,69 +366,31 @@ <h1>Source code for unitSI.unitsafefunctions</h1><div class="highlight"><pre>
 <span class="n">linspace</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">=</span> <span class="vm">__name__</span>
 </pre></div>
 
+           </div>
           </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../../index.html">unitSI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-<p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="../../modules.html">unitSI</a></li>
-</ul>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../../index.html">Documentation overview</a><ul>
-  <li><a href="../index.html">Module code</a><ul>
-  </ul></li>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
+          <footer>
 
+  <hr/>
 
+  <div role="contentinfo">
+    <p>&#169; Copyright 2024, Sorin Birchi.</p>
+  </div>
 
+  Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
+    <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+   
 
+</footer>
         </div>
       </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Sorin Birchi.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
+    </section>
+  </div>
+  <script>
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script> 
+
+</body>
 </html>
\ No newline at end of file
diff --git a/docs_sphinx/_build/html/_sources/developer/units.rst.txt b/docs_sphinx/_build/html/_sources/developer/units.rst.txt
index 216900f..98d2d5d 100644
--- a/docs_sphinx/_build/html/_sources/developer/units.rst.txt
+++ b/docs_sphinx/_build/html/_sources/developer/units.rst.txt
@@ -3,15 +3,8 @@ Units
 
 Casting rules
 -------------
-In Brian 1, a distinction is made between scalars and numpy arrays (including
-scalar arrays): Scalars could be multiplied with a unit, resulting in a Quantity
-object whereas the multiplication of an array with a unit resulted in a
-(unitless) array. Accordingly, scalars were considered as dimensionless
-quantities for the purpose of unit checking (e.g.. 1 + 1 * mV raised an error)
-whereas arrays were not (e.g. array(1) + 1 * mV resulted in 1.001 without any
-errors). Brian 2 no longer makes this distinction and treats both scalars and
-arrays as dimensionless for unit checking and make all operations involving
-quantities return a quantity.::
+unitSI treats both scalars and arrays as dimensionless for unit checking
+and make all operations involving quantities return a quantity.::
 
     >>> 1 + 1*second   # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
diff --git a/docs_sphinx/_build/html/_sources/index.rst.txt b/docs_sphinx/_build/html/_sources/index.rst.txt
index 4f3abdf..8405c6b 100644
--- a/docs_sphinx/_build/html/_sources/index.rst.txt
+++ b/docs_sphinx/_build/html/_sources/index.rst.txt
@@ -9,7 +9,9 @@ Welcome to unitSI's documentation!
 .. toctree::
    :maxdepth: 2
    :caption: Contents:
-
+         
+   user/units
+   developer/units
 
    modules
 
diff --git a/docs_sphinx/_build/html/_sources/unitSI.rst.txt b/docs_sphinx/_build/html/_sources/unitSI.rst.txt
index ed23dae..4754206 100644
--- a/docs_sphinx/_build/html/_sources/unitSI.rst.txt
+++ b/docs_sphinx/_build/html/_sources/unitSI.rst.txt
@@ -23,8 +23,3 @@ Submodules
 
 Module contents
 ---------------
-
-.. automodule:: unitSI
-   :members:
-   :undoc-members:
-   :show-inheritance:
diff --git a/docs_sphinx/_build/html/_sources/user/units.rst.txt b/docs_sphinx/_build/html/_sources/user/units.rst.txt
index 3675585..660431e 100644
--- a/docs_sphinx/_build/html/_sources/user/units.rst.txt
+++ b/docs_sphinx/_build/html/_sources/user/units.rst.txt
@@ -5,10 +5,10 @@ Physical units
     :local:
     :depth: 1
 
-Brian includes a system for physical units. The base units are defined by their
+unitSI is a system for physical units. The base units are defined by their
 standard SI unit names: ``amp``/``ampere``, ``kilogram``/``kilogramme``,
 ``second``, ``metre``/``meter``, ``mole``/``mol``, ``kelvin``, and ``candela``.
-In addition to these base units, Brian defines a set of derived units:
+In addition to these base units, unitSI defines a set of derived units:
 ``coulomb``, ``farad``, ``gram``/``gramme``, ``hertz``, ``joule``, ``liter``/
 ``litre``, ``molar``, ``pascal``, ``ohm``,  ``siemens``, ``volt``, ``watt``,
 together with prefixed versions (e.g. ``msiemens = 0.001*siemens``) using the
@@ -34,7 +34,7 @@ with its physical unit::
     >>> print(rates)
     [ 10.  20.  30.] Hz
 
-Brian will check the consistency of operations on units and raise an error for
+unitSI will check the consistency of operations on units and raise an error for
 dimensionality mismatches::
 
     >>> tau += 1  # ms? second?  # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
@@ -46,7 +46,7 @@ dimensionality mismatches::
     ...
     DimensionMismatchError: Cannot calculate 3. kg + 3. A, units do not match (units are kilogram and amp).
 
-Most Brian functions will also complain about non-specified or incorrect units::
+In Brian functions will also complain about non-specified or incorrect units::
 
     >>> G = NeuronGroup(10, 'dv/dt = -v/tau: volt', dt=0.5)   # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
@@ -86,8 +86,8 @@ analysis functions that do not correctly work with units)
 
 Temperatures
 ------------
-Brian only supports temperatures defined in °K, using the provided ``kelvin``
-unit object. Other conventions such as °C, or °F are not compatible with Brian's
+unitSI only supports temperatures defined in °K, using the provided ``kelvin``
+unit object. Other conventions such as °C, or °F are not compatible with unitSI
 unit system, because they cannot be expressed as a multiplicative scaling of the
 SI base unit kelvin (their zero point is different). However, in biological
 experiments and modeling, temperatures are typically reported in °C. How to use
@@ -105,15 +105,15 @@ absolute temperatures
     Equations such as the `Goldman–Hodgkin–Katz voltage equation <https://en.wikipedia.org/wiki/Goldman_equation>`_
     have a factor that depends on the absolute temperature measured in Kelvin.
     To get this temperature from a temperature reported in °C, you can use the
-    ``zero_celsius`` constant from the `brian2.units.constants` package (see
+    ``zero_celsius`` constant from the `unitSI.constants` package (see
     below)::
 
-        from brian2.units.constants import zero_celsius
+        from  unitSI.constants import zero_celsius
 
         celsius_temp = 27
         abs_temp = celsius_temp*kelvin + zero_celsius
 
-.. note:: Earlier versions of Brian had a ``celsius`` unit which was in fact
+.. note:: Earlier versions of unitSI had a ``celsius`` unit which was in fact
           identical to ``kelvin``. While this gave the correct results for
           temperature differences, it did not correctly work for absolute
           temperatures. To avoid confusion and possible misinterpretation,
@@ -123,12 +123,12 @@ absolute temperatures
 
 Constants
 ---------
-The `brian2.units.constants` package provides a range of physical constants that
-can be useful for detailed biological models. Brian provides the following
+The `unitSI.constants` package provides a range of physical constants that
+can be useful for detailed biological models. UnitSI provides the following
 constants:
 
 ==================== ================== ======================= ==================================================================
-Constant             Symbol(s)          Brian name              Value
+Constant             Symbol(s)          unitSI name              Value
 ==================== ================== ======================= ==================================================================
 Avogadro constant    :math:`N_A, L`     ``avogadro_constant``   :math:`6.022140857\times 10^{23}\,\mathrm{mol}^{-1}`
 Boltzmann constant   :math:`k`          ``boltzmann_constant``  :math:`1.38064852\times 10^{-23}\,\mathrm{J}\,\mathrm{K}^{-1}`
@@ -143,14 +143,14 @@ Molar mass constant  :math:`M_u`        ``molar_mass_constant`` :math:`1\times 1
 ==================== ================== ======================= ==================================================================
 
 Note that these constants are not imported by default, you will have to
-explicitly import them from `brian2.units.constants`. During the import, you
+explicitly import them from `unitSI.constants`. During the import, you
 can also give them shorter names using Python's ``from ... import ... as ...``
 syntax. For example, to calculate the :math:`\frac{RT}{F}` factor that appears
 in the `Goldman–Hodgkin–Katz voltage equation <https://en.wikipedia.org/wiki/Goldman_equation>`_
 you can use::
 
-    from brian2 import *
-    from brian2.units.constants import zero_celsius, gas_constant as R, faraday_constant as F
+    from unitSI import *
+    from unitSI.constants import zero_celsius, gas_constant as R, faraday_constant as F
 
     celsius_temp = 27
     T = celsius_temp*kelvin + zero_celsius
@@ -163,7 +163,7 @@ you can use::
 
 Importing units
 ---------------
-Brian generates standard names for units, combining the unit name (e.g.
+unitSI generates standard names for units, combining the unit name (e.g.
 "siemens") with a prefixes (e.g. "m"), and also generates squared and cubed
 versions by appending a number. For example, the units "msiemens", "siemens2",
 "usiemens3" are all predefined. You can import these units from the package
@@ -171,8 +171,7 @@ versions by appending a number. For example, the units "msiemens", "siemens2",
 ``from brian2.units.allunits import *`` will result in everything from
 ``Ylumen3`` (cubed yotta lumen) to ``ymol`` (yocto mole) being imported.
 
-A better choice is normally to do ``from brian2.units import *`` or import
-everything ``from brian2 import *`` which only imports the units mentioned in
+A better choice is normally to do ``from unitSI import *`` which only imports the units mentioned in
 the introductory paragraph (base units, derived units, and some standard
 abbreviations).
 
diff --git a/docs_sphinx/_build/html/developer/units.html b/docs_sphinx/_build/html/developer/units.html
index 4ebabe9..3cf9fe7 100644
--- a/docs_sphinx/_build/html/developer/units.html
+++ b/docs_sphinx/_build/html/developer/units.html
@@ -20,7 +20,9 @@
         <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="../_static/js/theme.js"></script>
     <link rel="index" title="Index" href="../genindex.html" />
-    <link rel="search" title="Search" href="../search.html" /> 
+    <link rel="search" title="Search" href="../search.html" />
+    <link rel="next" title="unitSI" href="../modules.html" />
+    <link rel="prev" title="Physical units" href="../user/units.html" /> 
 </head>
 
 <body class="wy-body-for-nav"> 
@@ -43,7 +45,18 @@
 </div>
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
-<ul>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="../user/units.html">Physical units</a></li>
+<li class="toctree-l1 current"><a class="current reference internal" href="#">Units</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#casting-rules">Casting rules</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#functions-and-units">Functions and units</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#ndarray-methods">ndarray methods</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#numpy-ufuncs">Numpy ufuncs</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#numpy-functions">Numpy functions</a></li>
+</ul>
+</li>
+</ul>
+</li>
 <li class="toctree-l1"><a class="reference internal" href="../modules.html">unitSI</a></li>
 </ul>
 
@@ -75,15 +88,8 @@
 <h1>Units<a class="headerlink" href="#units" title="Link to this heading"></a></h1>
 <section id="casting-rules">
 <h2>Casting rules<a class="headerlink" href="#casting-rules" title="Link to this heading"></a></h2>
-<p>In Brian 1, a distinction is made between scalars and numpy arrays (including
-scalar arrays): Scalars could be multiplied with a unit, resulting in a Quantity
-object whereas the multiplication of an array with a unit resulted in a
-(unitless) array. Accordingly, scalars were considered as dimensionless
-quantities for the purpose of unit checking (e.g.. 1 + 1 * mV raised an error)
-whereas arrays were not (e.g. array(1) + 1 * mV resulted in 1.001 without any
-errors). Brian 2 no longer makes this distinction and treats both scalars and
-arrays as dimensionless for unit checking and make all operations involving
-quantities return a quantity.:</p>
+<p>unitSI treats both scalars and arrays as dimensionless for unit checking
+and make all operations involving quantities return a quantity.:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="mi">1</span> <span class="o">+</span> <span class="mi">1</span><span class="o">*</span><span class="n">second</span>   
 <span class="gt">Traceback (most recent call last):</span>
 <span class="c">...</span>
@@ -252,7 +258,10 @@ <h3>Numpy functions<a class="headerlink" href="#numpy-functions" title="Link to
 
            </div>
           </div>
-          <footer>
+          <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
+        <a href="../user/units.html" class="btn btn-neutral float-left" title="Physical units" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
+        <a href="../modules.html" class="btn btn-neutral float-right" title="unitSI" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
+    </div>
 
   <hr/>
 
diff --git a/docs_sphinx/_build/html/genindex.html b/docs_sphinx/_build/html/genindex.html
index f6dd076..999629e 100644
--- a/docs_sphinx/_build/html/genindex.html
+++ b/docs_sphinx/_build/html/genindex.html
@@ -43,6 +43,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">unitSI</a></li>
 </ul>
 
@@ -101,87 +103,35 @@ <h2 id="A">A</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.all">all() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.all">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.any">any() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.any">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arange">arange() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arange">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arange">arange() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arccos">arccos() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arccos">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arccos">arccos() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arccosh">arccosh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arccosh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arccosh">arccosh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arcsin">arcsin() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arcsin">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arcsin">arcsin() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arcsinh">arcsinh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arcsinh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arcsinh">arcsinh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.arctan">arctan() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arctan">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arctan">arctan() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.arctanh">arctanh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arctanh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.arctanh">arctanh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.argmax">argmax() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.argmax">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.argmin">argmin() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.argmin">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.argsort">argsort() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.argsort">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.assert_quantity">assert_quantity() (in module unitSI.tests.test_units)</a>
 </li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.automatically_register_units">automatically_register_units (unitSI.fundamentalunits.Unit attribute)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.automatically_register_units">(unitSI.Unit attribute)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.constants.html#unitSI.constants.avogadro_constant">avogadro_constant (in module unitSI.constants)</a>
 </li>
   </ul></td>
@@ -198,106 +148,54 @@ <h2 id="B">B</h2>
 <h2 id="C">C</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.check_units">check_units() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.check_units">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.check_units">check_units() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.clip">clip() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.clip">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.cos">cos() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.cos">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.cos">cos() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.cosh">cosh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.cosh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.cosh">cosh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.create">create() (unitSI.fundamentalunits.Unit static method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.create">(unitSI.Unit static method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.create_scaled_unit">create_scaled_unit() (unitSI.fundamentalunits.Unit static method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.create_scaled_unit">(unitSI.Unit static method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.cumprod">cumprod() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.cumprod">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.cumsum">cumsum() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.cumsum">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="D">D</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.diagonal">diagonal() (in module unitSI)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.diagonal">diagonal() (in module unitSI.unitsafefunctions)</a>
 
       <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.diagonal">(in module unitSI.unitsafefunctions)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.diagonal">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.diagonal">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.dim">dim (unitSI.fundamentalunits.Quantity attribute)</a>
 
       <ul>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.dim">(unitSI.fundamentalunits.Unit attribute)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.dim">(unitSI.Quantity attribute)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Unit.dim">(unitSI.Unit attribute)</a>
 </li>
       </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.DimensionMismatchError">DimensionMismatchError</a>, <a href="unitSI.html#unitSI.DimensionMismatchError">[1]</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.DimensionMismatchError">DimensionMismatchError</a>
 </li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.dimensions">dimensions (unitSI.fundamentalunits.Quantity property)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.dimensions">(unitSI.Quantity property)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.dispname">dispname (unitSI.fundamentalunits.Unit property)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.dispname">(unitSI.Unit property)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.dot">dot() (in module unitSI)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.dot">dot() (in module unitSI.unitsafefunctions)</a>
 
       <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.dot">(in module unitSI.unitsafefunctions)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.dot">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.dot">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
   </ul></td>
@@ -312,26 +210,14 @@ <h2 id="E">E</h2>
 </li>
       <li><a href="unitSI.constants.html#unitSI.constants.elementary_charge">elementary_charge (in module unitSI.constants)</a>
 </li>
-      <li><a href="unitSI.html#unitSI.exp">exp() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.exp">(in module unitSI.unitsafefunctions)</a>
-</li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.expm1">expm1() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.expm1">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.exp">exp() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.exprel">exprel() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.exprel">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.expm1">expm1() (in module unitSI.unitsafefunctions)</a>
+</li>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.exprel">exprel() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -343,11 +229,7 @@ <h2 id="F">F</h2>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.fill">fill() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.fill">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -357,31 +239,15 @@ <h2 id="G">G</h2>
       <li><a href="unitSI.constants.html#unitSI.constants.gas_constant">gas_constant (in module unitSI.constants)</a>
 </li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.get_best_unit">get_best_unit() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.get_best_unit">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.get_dimensions">get_dimensions() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_dimensions">(in module unitSI.fundamentalunits)</a>
-</li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.get_or_create_dimension">get_or_create_dimension() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_or_create_dimension">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_dimensions">get_dimensions() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.get_unit">get_unit() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_unit">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_or_create_dimension">get_or_create_dimension() (in module unitSI.fundamentalunits)</a>
+</li>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.get_unit">get_unit() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -389,77 +255,41 @@ <h2 id="H">H</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.has_same_dimensions">has_same_dimensions() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.has_same_dimensions">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.have_same_dimensions">have_same_dimensions() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.have_same_dimensions">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.have_same_dimensions">have_same_dimensions() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="I">I</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.in_best_unit">in_best_unit() (in module unitSI)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_best_unit">in_best_unit() (in module unitSI.fundamentalunits)</a>
 
       <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_best_unit">(in module unitSI.fundamentalunits)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.in_best_unit">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.in_best_unit">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
-      <li><a href="unitSI.html#unitSI.in_unit">in_unit() (in module unitSI)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_unit">in_unit() (in module unitSI.fundamentalunits)</a>
 
       <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.in_unit">(in module unitSI.fundamentalunits)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.in_unit">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.in_unit">(unitSI.Quantity method)</a>
-</li>
-      </ul></li>
-      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.is_dimensionless">is_dimensionless (unitSI.fundamentalunits.Quantity property)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.is_dimensionless">(unitSI.Quantity property)</a>
 </li>
       </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.is_dimensionless">is_dimensionless() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_dimensionless">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.is_dimensionless">is_dimensionless (unitSI.fundamentalunits.Quantity property)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.is_scalar_type">is_scalar_type() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_scalar_type">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_dimensionless">is_dimensionless() (in module unitSI.fundamentalunits)</a>
+</li>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.is_scalar_type">is_scalar_type() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.iscompound">iscompound (unitSI.fundamentalunits.Unit attribute)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.iscompound">(unitSI.Unit attribute)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.item">item() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.item">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -467,37 +297,17 @@ <h2 id="L">L</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.latexname">latexname (unitSI.fundamentalunits.Unit property)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.latexname">(unitSI.Unit property)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.linspace">linspace() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.linspace">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.linspace">linspace() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.log">log() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log">(in module unitSI.unitsafefunctions)</a>
-</li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.log10">log10() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log10">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log">log() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.log1p">log1p() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log1p">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log10">log10() (in module unitSI.unitsafefunctions)</a>
+</li>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.log1p">log1p() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -507,37 +317,17 @@ <h2 id="M">M</h2>
       <li><a href="unitSI.constants.html#unitSI.constants.magnetic_constant">magnetic_constant (in module unitSI.constants)</a>
 </li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.matplotlib">matplotlib (unitSI.fundamentalunits.Quantity attribute)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.matplotlib">(unitSI.Quantity attribute)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.max">max() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.max">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.mean">mean() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.mean">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.min">min() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.min">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
       <li>
     module
 
       <ul>
-        <li><a href="unitSI.html#module-unitSI">unitSI</a>
-</li>
         <li><a href="unitSI.allunits.html#module-unitSI.allunits">unitSI.allunits</a>
 </li>
         <li><a href="unitSI.constants.html#module-unitSI.constants">unitSI.constants</a>
@@ -553,6 +343,8 @@ <h2 id="M">M</h2>
         <li><a href="unitSI.unitsafefunctions.html#module-unitSI.unitsafefunctions">unitSI.unitsafefunctions</a>
 </li>
       </ul></li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.constants.html#unitSI.constants.molar_mass_constant">molar_mass_constant (in module unitSI.constants)</a>
 </li>
   </ul></td>
@@ -562,31 +354,19 @@ <h2 id="N">N</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.name">name (unitSI.fundamentalunits.Unit property)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.name">(unitSI.Unit property)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.nonzero">nonzero() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.nonzero">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="O">O</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.ones_like">ones_like() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ones_like">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ones_like">ones_like() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -594,71 +374,43 @@ <h2 id="P">P</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.prod">prod() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.prod">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.ptp">ptp() (in module unitSI)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ptp">ptp() (in module unitSI.unitsafefunctions)</a>
 
       <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ptp">(in module unitSI.unitsafefunctions)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.ptp">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.ptp">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.put">put() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.put">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="Q">Q</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.Quantity">Quantity (class in unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity">(class in unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity">Quantity (class in unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="R">R</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.ravel">ravel() (in module unitSI)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ravel">ravel() (in module unitSI.unitsafefunctions)</a>
 
       <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.ravel">(in module unitSI.unitsafefunctions)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.ravel">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.ravel">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.register_new_unit">register_new_unit() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.register_new_unit">(in module unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.register_new_unit">register_new_unit() (in module unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.round">round() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.round">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -666,79 +418,35 @@ <h2 id="S">S</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.scale">scale (unitSI.fundamentalunits.Unit attribute)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.scale">(unitSI.Unit attribute)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.searchsorted">searchsorted() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.searchsorted">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_display_name">set_display_name() (unitSI.fundamentalunits.Unit method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.set_display_name">(unitSI.Unit method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_latex_name">set_latex_name() (unitSI.fundamentalunits.Unit method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.set_latex_name">(unitSI.Unit method)</a>
-</li>
-      </ul></li>
-      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_name">set_name() (unitSI.fundamentalunits.Unit method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Unit.set_name">(unitSI.Unit method)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.sin">sin() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.sin">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit.set_name">set_name() (unitSI.fundamentalunits.Unit method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.sinh">sinh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.sinh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.sin">sin() (in module unitSI.unitsafefunctions)</a>
+</li>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.sinh">sinh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.std">std() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.std">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.sum">sum() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.sum">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="T">T</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.tan">tan() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.tan">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.tan">tan() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.tanh">tanh() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.tanh">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.tanh">tanh() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_addition_subtraction">test_addition_subtraction() (in module unitSI.tests.test_units)</a>
 </li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_all_units_list">test_all_units_list() (in module unitSI.tests.test_units)</a>
@@ -774,11 +482,11 @@ <h2 id="T">T</h2>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_inplace_operations">test_inplace_operations() (in module unitSI.tests.test_units)</a>
 </li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_list">test_list() (in module unitSI.tests.test_units)</a>
-</li>
-      <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_multiplication_division">test_multiplication_division() (in module unitSI.tests.test_units)</a>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_multiplication_division">test_multiplication_division() (in module unitSI.tests.test_units)</a>
+</li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_numpy_functions_change_dimensions">test_numpy_functions_change_dimensions() (in module unitSI.tests.test_units)</a>
 </li>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_numpy_functions_dimensionless">test_numpy_functions_dimensionless() (in module unitSI.tests.test_units)</a>
@@ -814,19 +522,11 @@ <h2 id="T">T</h2>
       <li><a href="unitSI.tests.test_units.html#unitSI.tests.test_units.test_unitsafe_functions">test_unitsafe_functions() (in module unitSI.tests.test_units)</a>
 </li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.tolist">tolist() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.tolist">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
-      <li><a href="unitSI.html#unitSI.trace">trace() (in module unitSI)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.trace">trace() (in module unitSI.unitsafefunctions)</a>
 
       <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.trace">(in module unitSI.unitsafefunctions)</a>
-</li>
         <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.trace">(unitSI.fundamentalunits.Quantity method)</a>
-</li>
-        <li><a href="unitSI.html#unitSI.Quantity.trace">(unitSI.Quantity method)</a>
 </li>
       </ul></li>
   </ul></td>
@@ -835,19 +535,8 @@ <h2 id="T">T</h2>
 <h2 id="U">U</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.Unit">Unit (class in unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit">(class in unitSI.fundamentalunits)</a>
+      <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Unit">Unit (class in unitSI.fundamentalunits)</a>
 </li>
-      </ul></li>
-      <li>
-    unitSI
-
-      <ul>
-        <li><a href="unitSI.html#module-unitSI">module</a>
-</li>
-      </ul></li>
       <li>
     unitSI.allunits
 
@@ -869,8 +558,6 @@ <h2 id="U">U</h2>
         <li><a href="unitSI.fundamentalunits.html#module-unitSI.fundamentalunits">module</a>
 </li>
       </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
       <li>
     unitSI.stdunits
 
@@ -878,6 +565,8 @@ <h2 id="U">U</h2>
         <li><a href="unitSI.stdunits.html#module-unitSI.stdunits">module</a>
 </li>
       </ul></li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
       <li>
     unitSI.tests
 
@@ -900,11 +589,7 @@ <h2 id="U">U</h2>
 </li>
       </ul></li>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.use_matplotlib_units_fix">use_matplotlib_units_fix (unitSI.fundamentalunits.Quantity attribute)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.use_matplotlib_units_fix">(unitSI.Quantity attribute)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -912,31 +597,19 @@ <h2 id="V">V</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.var">var() (unitSI.fundamentalunits.Quantity method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.var">(unitSI.Quantity method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
 <h2 id="W">W</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.where">where() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.where">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.where">where() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity.with_dimensions">with_dimensions() (unitSI.fundamentalunits.Quantity static method)</a>
-
-      <ul>
-        <li><a href="unitSI.html#unitSI.Quantity.with_dimensions">(unitSI.Quantity static method)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
@@ -947,12 +620,8 @@ <h2 id="Z">Z</h2>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="unitSI.html#unitSI.zeros_like">zeros_like() (in module unitSI)</a>
-
-      <ul>
-        <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.zeros_like">(in module unitSI.unitsafefunctions)</a>
+      <li><a href="unitSI.unitsafefunctions.html#unitSI.unitsafefunctions.zeros_like">zeros_like() (in module unitSI.unitsafefunctions)</a>
 </li>
-      </ul></li>
   </ul></td>
 </tr></table>
 
diff --git a/docs_sphinx/_build/html/index.html b/docs_sphinx/_build/html/index.html
index a12cd1b..11116fb 100644
--- a/docs_sphinx/_build/html/index.html
+++ b/docs_sphinx/_build/html/index.html
@@ -22,7 +22,7 @@
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="unitSI" href="modules.html" /> 
+    <link rel="next" title="Physical units" href="user/units.html" /> 
 </head>
 
 <body class="wy-body-for-nav"> 
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">unitSI</a></li>
 </ul>
 
@@ -78,6 +80,20 @@ <h1>Welcome to unitSI’s documentation!<a class="headerlink" href="#welcome-to-
 <div class="toctree-wrapper compound">
 <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#using-units">Using units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#removing-units">Removing units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#temperatures">Temperatures</a></li>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#constants">Constants</a></li>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#importing-units">Importing units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="user/units.html#in-place-operations-on-quantities">In-place operations on quantities</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="developer/units.html#casting-rules">Casting rules</a></li>
+<li class="toctree-l2"><a class="reference internal" href="developer/units.html#functions-and-units">Functions and units</a></li>
+</ul>
+</li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">unitSI</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="unitSI.html">unitSI package</a></li>
 </ul>
@@ -98,7 +114,7 @@ <h1>Indices and tables<a class="headerlink" href="#indices-and-tables" title="Li
            </div>
           </div>
           <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
-        <a href="modules.html" class="btn btn-neutral float-right" title="unitSI" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
+        <a href="user/units.html" class="btn btn-neutral float-right" title="Physical units" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
     </div>
 
   <hr/>
diff --git a/docs_sphinx/_build/html/modules.html b/docs_sphinx/_build/html/modules.html
index 88fbd91..72482c9 100644
--- a/docs_sphinx/_build/html/modules.html
+++ b/docs_sphinx/_build/html/modules.html
@@ -23,7 +23,7 @@
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="unitSI package" href="unitSI.html" />
-    <link rel="prev" title="Welcome to unitSI’s documentation!" href="index.html" /> 
+    <link rel="prev" title="Units" href="developer/units.html" /> 
 </head>
 
 <body class="wy-body-for-nav"> 
@@ -47,6 +47,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="current reference internal" href="#">unitSI</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="unitSI.html">unitSI package</a></li>
 </ul>
@@ -84,7 +86,7 @@ <h1>unitSI<a class="headerlink" href="#unitsi" title="Link to this heading"><
 <li class="toctree-l1"><a class="reference internal" href="unitSI.html">unitSI package</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
 <li class="toctree-l2"><a class="reference internal" href="unitSI.html#submodules">Submodules</a></li>
-<li class="toctree-l2"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l2"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
@@ -95,7 +97,7 @@ <h1>unitSI<a class="headerlink" href="#unitsi" title="Link to this heading"><
            </div>
           </div>
           <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
-        <a href="index.html" class="btn btn-neutral float-left" title="Welcome to unitSI’s documentation!" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
+        <a href="developer/units.html" class="btn btn-neutral float-left" title="Units" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
         <a href="unitSI.html" class="btn btn-neutral float-right" title="unitSI package" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
     </div>
 
diff --git a/docs_sphinx/_build/html/objects.inv b/docs_sphinx/_build/html/objects.inv
index eb2f384..0f178bb 100644
Binary files a/docs_sphinx/_build/html/objects.inv and b/docs_sphinx/_build/html/objects.inv differ
diff --git a/docs_sphinx/_build/html/py-modindex.html b/docs_sphinx/_build/html/py-modindex.html
index 3c5711b..593b399 100644
--- a/docs_sphinx/_build/html/py-modindex.html
+++ b/docs_sphinx/_build/html/py-modindex.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">unitSI</a></li>
 </ul>
 
@@ -87,7 +89,7 @@ <h1>Python Module Index</h1>
        <td><img src="_static/minus.png" class="toggler"
               id="toggle-1" style="display: none" alt="-" /></td>
        <td>
-       <a href="unitSI.html#module-unitSI"><code class="xref">unitSI</code></a></td><td>
+       <code class="xref">unitSI</code></td><td>
        <em></em></td></tr>
      <tr class="cg-1">
        <td></td>
diff --git a/docs_sphinx/_build/html/search.html b/docs_sphinx/_build/html/search.html
index 6fe06d0..f31c2d9 100644
--- a/docs_sphinx/_build/html/search.html
+++ b/docs_sphinx/_build/html/search.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul>
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">unitSI</a></li>
 </ul>
 
diff --git a/docs_sphinx/_build/html/searchindex.js b/docs_sphinx/_build/html/searchindex.js
index 40f04dc..ed1b119 100644
--- a/docs_sphinx/_build/html/searchindex.js
+++ b/docs_sphinx/_build/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"Attributes": [[3, "attributes"], [6, "attributes"]], "Casting rules": [[0, "casting-rules"]], "Constants": [[11, "constants"]], "Contents:": [[1, null]], "Examples": [[3, "examples"], [3, "id11"], [3, "id17"], [3, "id21"], [3, "id40"], [3, "id48"], [3, "id55"], [3, "id65"], [3, "id73"], [3, "id82"], [3, "id90"], [3, "id100"], [3, "id101"], [3, "id109"], [3, "id114"], [3, "id119"], [3, "id124"], [3, "id134"], [3, "id141"], [3, "id145"], [3, "id153"], [3, "id157"], [3, "id166"], [3, "id176"], [3, "id186"], [3, "id196"], [3, "id200"], [3, "id203"], [3, "id208"], [3, "id210"], [3, "id217"], [3, "id224"], [3, "id231"], [3, "id240"], [3, "id244"], [3, "id249"], [3, "id253"], [6, "examples"], [6, "id11"], [6, "id17"], [6, "id21"], [6, "id40"], [6, "id45"], [6, "id50"], [6, "id58"], [6, "id62"], [6, "id69"], [10, "examples"], [10, "id6"], [10, "id16"], [10, "id24"], [10, "id33"], [10, "id41"], [10, "id51"], [10, "id58"], [10, "id63"], [10, "id67"], [10, "id72"], [10, "id82"], [10, "id89"], [10, "id93"], [10, "id103"], [10, "id113"], [10, "id123"], [10, "id127"], [10, "id130"], [10, "id135"], [10, "id142"], [10, "id149"], [10, "id156"], [10, "id165"], [10, "id169"], [10, "id174"], [10, "id178"]], "Functions and units": [[0, "functions-and-units"]], "Importing units": [[11, "importing-units"]], "In-place operations on quantities": [[11, "in-place-operations-on-quantities"]], "Indices and tables": [[1, "indices-and-tables"]], "Methods": [[3, "methods"], [6, "methods"]], "Module contents": [[3, "module-unitSI"], [8, "module-unitSI.tests"]], "Notes": [[3, "notes"], [3, "id54"], [3, "id61"], [3, "id71"], [3, "id78"], [3, "id88"], [3, "id96"], [3, "id102"], [3, "id107"], [3, "id130"], [3, "id140"], [3, "id146"], [3, "id172"], [3, "id182"], [3, "id192"], [3, "id207"], [3, "id216"], [3, "id222"], [3, "id229"], [3, "id236"], [3, "id248"], [6, "notes"], [6, "id46"], [6, "id51"], [10, "notes"], [10, "id12"], [10, "id22"], [10, "id29"], [10, "id39"], [10, "id47"], [10, "id56"], [10, "id78"], [10, "id88"], [10, "id99"], [10, "id109"], [10, "id119"], [10, "id134"], [10, "id141"], [10, "id147"], [10, "id154"], [10, "id161"], [10, "id173"]], "Numpy functions": [[0, "numpy-functions"]], "Numpy ufuncs": [[0, "numpy-ufuncs"]], "Parameters": [[3, "parameters"], [3, "id10"], [3, "id12"], [3, "id13"], [3, "id15"], [3, "id19"], [3, "id38"], [3, "id41"], [3, "id43"], [3, "id45"], [3, "id49"], [3, "id56"], [3, "id66"], [3, "id74"], [3, "id83"], [3, "id91"], [3, "id103"], [3, "id110"], [3, "id115"], [3, "id120"], [3, "id125"], [3, "id135"], [3, "id142"], [3, "id144"], [3, "id147"], [3, "id149"], [3, "id151"], [3, "id155"], [3, "id159"], [3, "id161"], [3, "id163"], [3, "id167"], [3, "id177"], [3, "id187"], [3, "id197"], [3, "id201"], [3, "id204"], [3, "id209"], [3, "id211"], [3, "id218"], [3, "id225"], [3, "id232"], [3, "id241"], [3, "id245"], [3, "id250"], [6, "parameters"], [6, "id10"], [6, "id12"], [6, "id13"], [6, "id15"], [6, "id19"], [6, "id38"], [6, "id41"], [6, "id43"], [6, "id47"], [6, "id49"], [6, "id52"], [6, "id54"], [6, "id56"], [6, "id60"], [6, "id64"], [6, "id66"], [6, "id68"], [10, "parameters"], [10, "id1"], [10, "id7"], [10, "id17"], [10, "id25"], [10, "id34"], [10, "id42"], [10, "id52"], [10, "id59"], [10, "id64"], [10, "id68"], [10, "id73"], [10, "id83"], [10, "id90"], [10, "id94"], [10, "id104"], [10, "id114"], [10, "id124"], [10, "id128"], [10, "id131"], [10, "id136"], [10, "id143"], [10, "id150"], [10, "id157"], [10, "id166"], [10, "id170"], [10, "id175"]], "Physical units": [[11, "physical-units"]], "Raises": [[3, "raises"], [3, "id117"], [3, "id122"], [6, "raises"], [10, "raises"], [10, "id70"]], "References": [[3, "references"], [3, "id62"], [3, "id72"], [3, "id79"], [3, "id89"], [3, "id97"], [3, "id108"], [3, "id131"], [3, "id173"], [3, "id183"], [3, "id193"], [3, "id223"], [3, "id230"], [3, "id237"], [10, "references"], [10, "id13"], [10, "id23"], [10, "id30"], [10, "id40"], [10, "id48"], [10, "id57"], [10, "id79"], [10, "id100"], [10, "id110"], [10, "id120"], [10, "id148"], [10, "id155"], [10, "id162"]], "Removing units": [[11, "removing-units"]], "Returns": [[3, "returns"], [3, "id14"], [3, "id16"], [3, "id20"], [3, "id35"], [3, "id39"], [3, "id42"], [3, "id44"], [3, "id46"], [3, "id52"], [3, "id59"], [3, "id69"], [3, "id77"], [3, "id86"], [3, "id94"], [3, "id106"], [3, "id113"], [3, "id116"], [3, "id121"], [3, "id128"], [3, "id138"], [3, "id143"], [3, "id148"], [3, "id150"], [3, "id152"], [3, "id156"], [3, "id160"], [3, "id162"], [3, "id164"], [3, "id170"], [3, "id180"], [3, "id190"], [3, "id198"], [3, "id202"], [3, "id205"], [3, "id214"], [3, "id221"], [3, "id228"], [3, "id235"], [3, "id242"], [3, "id246"], [3, "id251"], [6, "returns"], [6, "id14"], [6, "id16"], [6, "id20"], [6, "id35"], [6, "id39"], [6, "id42"], [6, "id44"], [6, "id48"], [6, "id53"], [6, "id55"], [6, "id57"], [6, "id61"], [6, "id65"], [6, "id67"], [10, "returns"], [10, "id4"], [10, "id10"], [10, "id20"], [10, "id28"], [10, "id37"], [10, "id45"], [10, "id55"], [10, "id62"], [10, "id65"], [10, "id69"], [10, "id76"], [10, "id86"], [10, "id91"], [10, "id97"], [10, "id107"], [10, "id117"], [10, "id125"], [10, "id129"], [10, "id132"], [10, "id139"], [10, "id146"], [10, "id153"], [10, "id160"], [10, "id167"], [10, "id171"], [10, "id176"]], "See Also": [[3, "id1"], [3, "id2"], [3, "id3"], [3, "id4"], [3, "id5"], [3, "id6"], [3, "id7"], [3, "id8"], [3, "id9"], [3, "id18"], [3, "id22"], [3, "id23"], [3, "id24"], [3, "id25"], [3, "id26"], [3, "id27"], [3, "id28"], [3, "id29"], [3, "id30"], [3, "id31"], [3, "id32"], [3, "id33"], [3, "id34"], [3, "id36"], [3, "id37"], [3, "id47"], [3, "id53"], [3, "id60"], [3, "id70"], [3, "id87"], [3, "id95"], [3, "id118"], [3, "id123"], [3, "id129"], [3, "id139"], [3, "id154"], [3, "id158"], [3, "id165"], [3, "id171"], [3, "id181"], [3, "id191"], [3, "id199"], [3, "id206"], [3, "id215"], [3, "id243"], [3, "id247"], [3, "id252"], [6, "id1"], [6, "id2"], [6, "id3"], [6, "id4"], [6, "id5"], [6, "id6"], [6, "id7"], [6, "id8"], [6, "id9"], [6, "id18"], [6, "id22"], [6, "id23"], [6, "id24"], [6, "id25"], [6, "id26"], [6, "id27"], [6, "id28"], [6, "id29"], [6, "id30"], [6, "id31"], [6, "id32"], [6, "id33"], [6, "id34"], [6, "id36"], [6, "id37"], [6, "id59"], [6, "id63"], [10, "see-also"], [10, "id5"], [10, "id11"], [10, "id21"], [10, "id38"], [10, "id46"], [10, "id66"], [10, "id71"], [10, "id77"], [10, "id87"], [10, "id92"], [10, "id98"], [10, "id108"], [10, "id118"], [10, "id126"], [10, "id133"], [10, "id140"], [10, "id168"], [10, "id172"], [10, "id177"]], "See also": [[3, "see-also"], [6, "see-also"]], "Submodules": [[3, "submodules"], [8, "submodules"]], "Subpackages": [[3, "subpackages"]], "Temperatures": [[11, "temperatures"]], "The following topics are not essential for beginners.": [[11, null]], "Units": [[0, "units"]], "Using units": [[11, "using-units"]], "Warnings": [[3, "warnings"], [10, "warnings"]], "Welcome to unitSI\u2019s documentation!": [[1, "welcome-to-unitsi-s-documentation"]], "ndarray methods": [[0, "ndarray-methods"]], "unitSI": [[2, "unitsi"]], "unitSI package": [[3, "unitsi-package"]], "unitSI.allunits module": [[4, "module-unitSI.allunits"]], "unitSI.constants module": [[5, "module-unitSI.constants"]], "unitSI.fundamentalunits module": [[6, "module-unitSI.fundamentalunits"]], "unitSI.stdunits module": [[7, "module-unitSI.stdunits"]], "unitSI.tests package": [[8, "unitsi-tests-package"]], "unitSI.tests.test_units module": [[9, "module-unitSI.tests.test_units"]], "unitSI.unitsafefunctions module": [[10, "module-unitSI.unitsafefunctions"]]}, "docnames": ["developer/units", "index", "modules", "unitSI", "unitSI.allunits", "unitSI.constants", "unitSI.fundamentalunits", "unitSI.stdunits", "unitSI.tests", "unitSI.tests.test_units", "unitSI.unitsafefunctions", "user/units"], "envversion": {"sphinx": 61, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1}, "filenames": ["developer/units.rst", "index.rst", "modules.rst", "unitSI.rst", "unitSI.allunits.rst", "unitSI.constants.rst", "unitSI.fundamentalunits.rst", "unitSI.stdunits.rst", "unitSI.tests.rst", "unitSI.tests.test_units.rst", "unitSI.unitsafefunctions.rst", "user/units.rst"], "indexentries": {"all() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.all", false]], "all() (unitsi.quantity method)": [[3, "unitSI.Quantity.all", false]], "any() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.any", false]], "any() (unitsi.quantity method)": [[3, "unitSI.Quantity.any", false]], "arange() (in module unitsi)": [[3, "unitSI.arange", false]], "arange() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arange", false]], "arccos() (in module unitsi)": [[3, "unitSI.arccos", false]], "arccos() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arccos", false]], "arccosh() (in module unitsi)": [[3, "unitSI.arccosh", false]], "arccosh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arccosh", false]], "arcsin() (in module unitsi)": [[3, "unitSI.arcsin", false]], "arcsin() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arcsin", false]], "arcsinh() (in module unitsi)": [[3, "unitSI.arcsinh", false]], "arcsinh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arcsinh", false]], "arctan() (in module unitsi)": [[3, "unitSI.arctan", false]], "arctan() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arctan", false]], "arctanh() (in module unitsi)": [[3, "unitSI.arctanh", false]], "arctanh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.arctanh", false]], "argmax() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.argmax", false]], "argmax() (unitsi.quantity method)": [[3, "unitSI.Quantity.argmax", false]], "argmin() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.argmin", false]], "argmin() (unitsi.quantity method)": [[3, "unitSI.Quantity.argmin", false]], "argsort() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.argsort", false]], "argsort() (unitsi.quantity method)": [[3, "unitSI.Quantity.argsort", false]], "assert_quantity() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.assert_quantity", false]], "automatically_register_units (unitsi.fundamentalunits.unit attribute)": [[6, "unitSI.fundamentalunits.Unit.automatically_register_units", false]], "automatically_register_units (unitsi.unit attribute)": [[3, "unitSI.Unit.automatically_register_units", false]], "avogadro_constant (in module unitsi.constants)": [[5, "unitSI.constants.avogadro_constant", false]], "boltzmann_constant (in module unitsi.constants)": [[5, "unitSI.constants.boltzmann_constant", false]], "check_units() (in module unitsi)": [[3, "unitSI.check_units", false]], "check_units() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.check_units", false]], "clip() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.clip", false]], "clip() (unitsi.quantity method)": [[3, "unitSI.Quantity.clip", false]], "cos() (in module unitsi)": [[3, "unitSI.cos", false]], "cos() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.cos", false]], "cosh() (in module unitsi)": [[3, "unitSI.cosh", false]], "cosh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.cosh", false]], "create() (unitsi.fundamentalunits.unit static method)": [[6, "unitSI.fundamentalunits.Unit.create", false]], "create() (unitsi.unit static method)": [[3, "unitSI.Unit.create", false]], "create_scaled_unit() (unitsi.fundamentalunits.unit static method)": [[6, "unitSI.fundamentalunits.Unit.create_scaled_unit", false]], "create_scaled_unit() (unitsi.unit static method)": [[3, "unitSI.Unit.create_scaled_unit", false]], "cumprod() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.cumprod", false]], "cumprod() (unitsi.quantity method)": [[3, "unitSI.Quantity.cumprod", false]], "cumsum() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.cumsum", false]], "cumsum() (unitsi.quantity method)": [[3, "unitSI.Quantity.cumsum", false]], "diagonal() (in module unitsi)": [[3, "unitSI.diagonal", false]], "diagonal() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.diagonal", false]], "diagonal() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.diagonal", false]], "diagonal() (unitsi.quantity method)": [[3, "unitSI.Quantity.diagonal", false]], "dim (unitsi.fundamentalunits.quantity attribute)": [[6, "unitSI.fundamentalunits.Quantity.dim", false]], "dim (unitsi.fundamentalunits.unit attribute)": [[6, "unitSI.fundamentalunits.Unit.dim", false]], "dim (unitsi.quantity attribute)": [[3, "unitSI.Quantity.dim", false]], "dim (unitsi.unit attribute)": [[3, "unitSI.Unit.dim", false]], "dimensionmismatcherror": [[3, "unitSI.DimensionMismatchError", false], [6, "unitSI.fundamentalunits.DimensionMismatchError", false]], "dimensions (unitsi.fundamentalunits.quantity property)": [[6, "unitSI.fundamentalunits.Quantity.dimensions", false]], "dimensions (unitsi.quantity property)": [[3, "unitSI.Quantity.dimensions", false]], "dispname (unitsi.fundamentalunits.unit property)": [[6, "unitSI.fundamentalunits.Unit.dispname", false]], "dispname (unitsi.unit property)": [[3, "unitSI.Unit.dispname", false]], "dot() (in module unitsi)": [[3, "unitSI.dot", false]], "dot() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.dot", false]], "dot() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.dot", false]], "dot() (unitsi.quantity method)": [[3, "unitSI.Quantity.dot", false]], "electric_constant (in module unitsi.constants)": [[5, "unitSI.constants.electric_constant", false]], "electron_mass (in module unitsi.constants)": [[5, "unitSI.constants.electron_mass", false]], "elementary_charge (in module unitsi.constants)": [[5, "unitSI.constants.elementary_charge", false]], "exp() (in module unitsi)": [[3, "unitSI.exp", false]], "exp() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.exp", false]], "expm1() (in module unitsi)": [[3, "unitSI.expm1", false]], "expm1() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.expm1", false]], "exprel() (in module unitsi)": [[3, "unitSI.exprel", false]], "exprel() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.exprel", false]], "faraday_constant (in module unitsi.constants)": [[5, "unitSI.constants.faraday_constant", false]], "fill() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.fill", false]], "fill() (unitsi.quantity method)": [[3, "unitSI.Quantity.fill", false]], "gas_constant (in module unitsi.constants)": [[5, "unitSI.constants.gas_constant", false]], "get_best_unit() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.get_best_unit", false]], "get_best_unit() (unitsi.quantity method)": [[3, "unitSI.Quantity.get_best_unit", false]], "get_dimensions() (in module unitsi)": [[3, "unitSI.get_dimensions", false]], "get_dimensions() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.get_dimensions", false]], "get_or_create_dimension() (in module unitsi)": [[3, "unitSI.get_or_create_dimension", false]], "get_or_create_dimension() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.get_or_create_dimension", false]], "get_unit() (in module unitsi)": [[3, "unitSI.get_unit", false]], "get_unit() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.get_unit", false]], "has_same_dimensions() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.has_same_dimensions", false]], "has_same_dimensions() (unitsi.quantity method)": [[3, "unitSI.Quantity.has_same_dimensions", false]], "have_same_dimensions() (in module unitsi)": [[3, "unitSI.have_same_dimensions", false]], "have_same_dimensions() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.have_same_dimensions", false]], "in_best_unit() (in module unitsi)": [[3, "unitSI.in_best_unit", false]], "in_best_unit() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.in_best_unit", false]], "in_best_unit() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.in_best_unit", false]], "in_best_unit() (unitsi.quantity method)": [[3, "unitSI.Quantity.in_best_unit", false]], "in_unit() (in module unitsi)": [[3, "unitSI.in_unit", false]], "in_unit() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.in_unit", false]], "in_unit() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.in_unit", false]], "in_unit() (unitsi.quantity method)": [[3, "unitSI.Quantity.in_unit", false]], "is_dimensionless (unitsi.fundamentalunits.quantity property)": [[6, "unitSI.fundamentalunits.Quantity.is_dimensionless", false]], "is_dimensionless (unitsi.quantity property)": [[3, "unitSI.Quantity.is_dimensionless", false]], "is_dimensionless() (in module unitsi)": [[3, "unitSI.is_dimensionless", false]], "is_dimensionless() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.is_dimensionless", false]], "is_scalar_type() (in module unitsi)": [[3, "unitSI.is_scalar_type", false]], "is_scalar_type() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.is_scalar_type", false]], "iscompound (unitsi.fundamentalunits.unit attribute)": [[6, "unitSI.fundamentalunits.Unit.iscompound", false]], "iscompound (unitsi.unit attribute)": [[3, "unitSI.Unit.iscompound", false]], "item() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.item", false]], "item() (unitsi.quantity method)": [[3, "unitSI.Quantity.item", false]], "latexname (unitsi.fundamentalunits.unit property)": [[6, "unitSI.fundamentalunits.Unit.latexname", false]], "latexname (unitsi.unit property)": [[3, "unitSI.Unit.latexname", false]], "linspace() (in module unitsi)": [[3, "unitSI.linspace", false]], "linspace() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.linspace", false]], "log() (in module unitsi)": [[3, "unitSI.log", false]], "log() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.log", false]], "log10() (in module unitsi)": [[3, "unitSI.log10", false]], "log10() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.log10", false]], "log1p() (in module unitsi)": [[3, "unitSI.log1p", false]], "log1p() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.log1p", false]], "magnetic_constant (in module unitsi.constants)": [[5, "unitSI.constants.magnetic_constant", false]], "matplotlib (unitsi.fundamentalunits.quantity attribute)": [[6, "unitSI.fundamentalunits.Quantity.matplotlib", false]], "matplotlib (unitsi.quantity attribute)": [[3, "unitSI.Quantity.matplotlib", false]], "max() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.max", false]], "max() (unitsi.quantity method)": [[3, "unitSI.Quantity.max", false]], "mean() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.mean", false]], "mean() (unitsi.quantity method)": [[3, "unitSI.Quantity.mean", false]], "min() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.min", false]], "min() (unitsi.quantity method)": [[3, "unitSI.Quantity.min", false]], "module": [[3, "module-unitSI", false], [4, "module-unitSI.allunits", false], [5, "module-unitSI.constants", false], [6, "module-unitSI.fundamentalunits", false], [7, "module-unitSI.stdunits", false], [8, "module-unitSI.tests", false], [9, "module-unitSI.tests.test_units", false], [10, "module-unitSI.unitsafefunctions", false]], "molar_mass_constant (in module unitsi.constants)": [[5, "unitSI.constants.molar_mass_constant", false]], "name (unitsi.fundamentalunits.unit property)": [[6, "unitSI.fundamentalunits.Unit.name", false]], "name (unitsi.unit property)": [[3, "unitSI.Unit.name", false]], "nonzero() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.nonzero", false]], "nonzero() (unitsi.quantity method)": [[3, "unitSI.Quantity.nonzero", false]], "ones_like() (in module unitsi)": [[3, "unitSI.ones_like", false]], "ones_like() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.ones_like", false]], "prod() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.prod", false]], "prod() (unitsi.quantity method)": [[3, "unitSI.Quantity.prod", false]], "ptp() (in module unitsi)": [[3, "unitSI.ptp", false]], "ptp() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.ptp", false]], "ptp() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.ptp", false]], "ptp() (unitsi.quantity method)": [[3, "unitSI.Quantity.ptp", false]], "put() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.put", false]], "put() (unitsi.quantity method)": [[3, "unitSI.Quantity.put", false]], "quantity (class in unitsi)": [[3, "unitSI.Quantity", false]], "quantity (class in unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.Quantity", false]], "ravel() (in module unitsi)": [[3, "unitSI.ravel", false]], "ravel() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.ravel", false]], "ravel() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.ravel", false]], "ravel() (unitsi.quantity method)": [[3, "unitSI.Quantity.ravel", false]], "register_new_unit() (in module unitsi)": [[3, "unitSI.register_new_unit", false]], "register_new_unit() (in module unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.register_new_unit", false]], "round() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.round", false]], "round() (unitsi.quantity method)": [[3, "unitSI.Quantity.round", false]], "scale (unitsi.fundamentalunits.unit attribute)": [[6, "unitSI.fundamentalunits.Unit.scale", false]], "scale (unitsi.unit attribute)": [[3, "unitSI.Unit.scale", false]], "searchsorted() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.searchsorted", false]], "searchsorted() (unitsi.quantity method)": [[3, "unitSI.Quantity.searchsorted", false]], "set_display_name() (unitsi.fundamentalunits.unit method)": [[6, "unitSI.fundamentalunits.Unit.set_display_name", false]], "set_display_name() (unitsi.unit method)": [[3, "unitSI.Unit.set_display_name", false]], "set_latex_name() (unitsi.fundamentalunits.unit method)": [[6, "unitSI.fundamentalunits.Unit.set_latex_name", false]], "set_latex_name() (unitsi.unit method)": [[3, "unitSI.Unit.set_latex_name", false]], "set_name() (unitsi.fundamentalunits.unit method)": [[6, "unitSI.fundamentalunits.Unit.set_name", false]], "set_name() (unitsi.unit method)": [[3, "unitSI.Unit.set_name", false]], "sin() (in module unitsi)": [[3, "unitSI.sin", false]], "sin() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.sin", false]], "sinh() (in module unitsi)": [[3, "unitSI.sinh", false]], "sinh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.sinh", false]], "std() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.std", false]], "std() (unitsi.quantity method)": [[3, "unitSI.Quantity.std", false]], "sum() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.sum", false]], "sum() (unitsi.quantity method)": [[3, "unitSI.Quantity.sum", false]], "tan() (in module unitsi)": [[3, "unitSI.tan", false]], "tan() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.tan", false]], "tanh() (in module unitsi)": [[3, "unitSI.tanh", false]], "tanh() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.tanh", false]], "test_addition_subtraction() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_addition_subtraction", false]], "test_all_units_list() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_all_units_list", false]], "test_arange_linspace() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_arange_linspace", false]], "test_binary_operations() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_binary_operations", false]], "test_check_units() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_check_units", false]], "test_constants() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_constants", false]], "test_construction() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_construction", false]], "test_deepcopy() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_deepcopy", false]], "test_dimension_singletons() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_dimension_singletons", false]], "test_display() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_display", false]], "test_fail_for_dimension_mismatch() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_fail_for_dimension_mismatch", false]], "test_format_quantity() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_format_quantity", false]], "test_get_best_unit() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_get_best_unit", false]], "test_get_dimensions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_get_dimensions", false]], "test_get_unit() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_get_unit", false]], "test_inplace_on_scalars() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_inplace_on_scalars", false]], "test_inplace_operations() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_inplace_operations", false]], "test_list() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_list", false]], "test_multiplication_division() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_multiplication_division", false]], "test_numpy_functions_change_dimensions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_change_dimensions", false]], "test_numpy_functions_dimensionless() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_dimensionless", false]], "test_numpy_functions_indices() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_indices", false]], "test_numpy_functions_logical() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_logical", false]], "test_numpy_functions_same_dimensions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_same_dimensions", false]], "test_numpy_functions_typeerror() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_numpy_functions_typeerror", false]], "test_pickling() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_pickling", false]], "test_power() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_power", false]], "test_setting() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_setting", false]], "test_slicing() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_slicing", false]], "test_special_case_numpy_functions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_special_case_numpy_functions", false]], "test_str_repr() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_str_repr", false]], "test_switching_off_unit_checks() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_switching_off_unit_checks", false]], "test_unary_operations() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_unary_operations", false]], "test_unit_discarding_functions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_unit_discarding_functions", false]], "test_units_vs_quantities() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_units_vs_quantities", false]], "test_unitsafe_functions() (in module unitsi.tests.test_units)": [[9, "unitSI.tests.test_units.test_unitsafe_functions", false]], "tolist() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.tolist", false]], "tolist() (unitsi.quantity method)": [[3, "unitSI.Quantity.tolist", false]], "trace() (in module unitsi)": [[3, "unitSI.trace", false]], "trace() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.trace", false]], "trace() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.trace", false]], "trace() (unitsi.quantity method)": [[3, "unitSI.Quantity.trace", false]], "unit (class in unitsi)": [[3, "unitSI.Unit", false]], "unit (class in unitsi.fundamentalunits)": [[6, "unitSI.fundamentalunits.Unit", false]], "unitsi": [[3, "module-unitSI", false]], "unitsi.allunits": [[4, "module-unitSI.allunits", false]], "unitsi.constants": [[5, "module-unitSI.constants", false]], "unitsi.fundamentalunits": [[6, "module-unitSI.fundamentalunits", false]], "unitsi.stdunits": [[7, "module-unitSI.stdunits", false]], "unitsi.tests": [[8, "module-unitSI.tests", false]], "unitsi.tests.test_units": [[9, "module-unitSI.tests.test_units", false]], "unitsi.unitsafefunctions": [[10, "module-unitSI.unitsafefunctions", false]], "use_matplotlib_units_fix (unitsi.fundamentalunits.quantity attribute)": [[6, "unitSI.fundamentalunits.Quantity.use_matplotlib_units_fix", false]], "use_matplotlib_units_fix (unitsi.quantity attribute)": [[3, "unitSI.Quantity.use_matplotlib_units_fix", false]], "var() (unitsi.fundamentalunits.quantity method)": [[6, "unitSI.fundamentalunits.Quantity.var", false]], "var() (unitsi.quantity method)": [[3, "unitSI.Quantity.var", false]], "where() (in module unitsi)": [[3, "unitSI.where", false]], "where() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.where", false]], "with_dimensions() (unitsi.fundamentalunits.quantity static method)": [[6, "unitSI.fundamentalunits.Quantity.with_dimensions", false]], "with_dimensions() (unitsi.quantity static method)": [[3, "unitSI.Quantity.with_dimensions", false]], "zero_celsius (in module unitsi.constants)": [[5, "unitSI.constants.zero_celsius", false]], "zeros_like() (in module unitsi)": [[3, "unitSI.zeros_like", false]], "zeros_like() (in module unitsi.unitsafefunctions)": [[10, "unitSI.unitsafefunctions.zeros_like", false]]}, "objects": {"": [[3, 0, 0, "-", "unitSI"]], "unitSI": [[3, 1, 1, "", "DimensionMismatchError"], [3, 2, 1, "", "Quantity"], [3, 2, 1, "", "Unit"], [4, 0, 0, "-", "allunits"], [3, 6, 1, "", "arange"], [3, 6, 1, "", "arccos"], [3, 6, 1, "", "arccosh"], [3, 6, 1, "", "arcsin"], [3, 6, 1, "", "arcsinh"], [3, 6, 1, "", "arctan"], [3, 6, 1, "", "arctanh"], [3, 6, 1, "", "check_units"], [5, 0, 0, "-", "constants"], [3, 6, 1, "", "cos"], [3, 6, 1, "", "cosh"], [3, 6, 1, "", "diagonal"], [3, 6, 1, "", "dot"], [3, 6, 1, "", "exp"], [3, 6, 1, "", "expm1"], [3, 6, 1, "", "exprel"], [6, 0, 0, "-", "fundamentalunits"], [3, 6, 1, "", "get_dimensions"], [3, 6, 1, "", "get_or_create_dimension"], [3, 6, 1, "", "get_unit"], [3, 6, 1, "", "have_same_dimensions"], [3, 6, 1, "", "in_best_unit"], [3, 6, 1, "", "in_unit"], [3, 6, 1, "", "is_dimensionless"], [3, 6, 1, "", "is_scalar_type"], [3, 6, 1, "", "linspace"], [3, 6, 1, "", "log"], [3, 6, 1, "", "log10"], [3, 6, 1, "", "log1p"], [3, 6, 1, "", "ones_like"], [3, 6, 1, "", "ptp"], [3, 6, 1, "", "ravel"], [3, 6, 1, "", "register_new_unit"], [3, 6, 1, "", "sin"], [3, 6, 1, "", "sinh"], [7, 0, 0, "-", "stdunits"], [3, 6, 1, "", "tan"], [3, 6, 1, "", "tanh"], [8, 0, 0, "-", "tests"], [3, 6, 1, "", "trace"], [10, 0, 0, "-", "unitsafefunctions"], [3, 6, 1, "", "where"], [3, 6, 1, "", "zeros_like"]], "unitSI.Quantity": [[3, 3, 1, "", "all"], [3, 3, 1, "", "any"], [3, 3, 1, "", "argmax"], [3, 3, 1, "", "argmin"], [3, 3, 1, "", "argsort"], [3, 3, 1, "", "clip"], [3, 3, 1, "", "cumprod"], [3, 3, 1, "", "cumsum"], [3, 3, 1, "", "diagonal"], [3, 4, 1, "", "dim"], [3, 5, 1, "", "dimensions"], [3, 3, 1, "", "dot"], [3, 3, 1, "", "fill"], [3, 3, 1, "", "get_best_unit"], [3, 3, 1, "", "has_same_dimensions"], [3, 3, 1, "", "in_best_unit"], [3, 3, 1, "", "in_unit"], [3, 5, 1, "", "is_dimensionless"], [3, 3, 1, "", "item"], [3, 4, 1, "", "matplotlib"], [3, 3, 1, "", "max"], [3, 3, 1, "", "mean"], [3, 3, 1, "", "min"], [3, 3, 1, "", "nonzero"], [3, 3, 1, "", "prod"], [3, 3, 1, "", "ptp"], [3, 3, 1, "", "put"], [3, 3, 1, "", "ravel"], [3, 3, 1, "", "round"], [3, 3, 1, "", "searchsorted"], [3, 3, 1, "", "std"], [3, 3, 1, "", "sum"], [3, 3, 1, "", "tolist"], [3, 3, 1, "", "trace"], [3, 4, 1, "", "use_matplotlib_units_fix"], [3, 3, 1, "", "var"], [3, 3, 1, "", "with_dimensions"]], "unitSI.Unit": [[3, 4, 1, "", "automatically_register_units"], [3, 3, 1, "", "create"], [3, 3, 1, "", "create_scaled_unit"], [3, 4, 1, "", "dim"], [3, 5, 1, "", "dispname"], [3, 4, 1, "", "iscompound"], [3, 5, 1, "", "latexname"], [3, 5, 1, "", "name"], [3, 4, 1, "", "scale"], [3, 3, 1, "", "set_display_name"], [3, 3, 1, "", "set_latex_name"], [3, 3, 1, "", "set_name"]], "unitSI.constants": [[5, 7, 1, "", "avogadro_constant"], [5, 7, 1, "", "boltzmann_constant"], [5, 7, 1, "", "electric_constant"], [5, 7, 1, "", "electron_mass"], [5, 7, 1, "", "elementary_charge"], [5, 7, 1, "", "faraday_constant"], [5, 7, 1, "", "gas_constant"], [5, 7, 1, "", "magnetic_constant"], [5, 7, 1, "", "molar_mass_constant"], [5, 7, 1, "", "zero_celsius"]], "unitSI.fundamentalunits": [[6, 1, 1, "", "DimensionMismatchError"], [6, 2, 1, "", "Quantity"], [6, 2, 1, "", "Unit"], [6, 6, 1, "", "check_units"], [6, 6, 1, "", "get_dimensions"], [6, 6, 1, "", "get_or_create_dimension"], [6, 6, 1, "", "get_unit"], [6, 6, 1, "", "have_same_dimensions"], [6, 6, 1, "", "in_best_unit"], [6, 6, 1, "", "in_unit"], [6, 6, 1, "", "is_dimensionless"], [6, 6, 1, "", "is_scalar_type"], [6, 6, 1, "", "register_new_unit"]], "unitSI.fundamentalunits.Quantity": [[6, 3, 1, "", "all"], [6, 3, 1, "", "any"], [6, 3, 1, "", "argmax"], [6, 3, 1, "", "argmin"], [6, 3, 1, "", "argsort"], [6, 3, 1, "", "clip"], [6, 3, 1, "", "cumprod"], [6, 3, 1, "", "cumsum"], [6, 3, 1, "", "diagonal"], [6, 4, 1, "", "dim"], [6, 5, 1, "", "dimensions"], [6, 3, 1, "", "dot"], [6, 3, 1, "", "fill"], [6, 3, 1, "", "get_best_unit"], [6, 3, 1, "", "has_same_dimensions"], [6, 3, 1, "", "in_best_unit"], [6, 3, 1, "", "in_unit"], [6, 5, 1, "", "is_dimensionless"], [6, 3, 1, "", "item"], [6, 4, 1, "", "matplotlib"], [6, 3, 1, "", "max"], [6, 3, 1, "", "mean"], [6, 3, 1, "", "min"], [6, 3, 1, "", "nonzero"], [6, 3, 1, "", "prod"], [6, 3, 1, "", "ptp"], [6, 3, 1, "", "put"], [6, 3, 1, "", "ravel"], [6, 3, 1, "", "round"], [6, 3, 1, "", "searchsorted"], [6, 3, 1, "", "std"], [6, 3, 1, "", "sum"], [6, 3, 1, "", "tolist"], [6, 3, 1, "", "trace"], [6, 4, 1, "", "use_matplotlib_units_fix"], [6, 3, 1, "", "var"], [6, 3, 1, "", "with_dimensions"]], "unitSI.fundamentalunits.Unit": [[6, 4, 1, "", "automatically_register_units"], [6, 3, 1, "", "create"], [6, 3, 1, "", "create_scaled_unit"], [6, 4, 1, "", "dim"], [6, 5, 1, "", "dispname"], [6, 4, 1, "", "iscompound"], [6, 5, 1, "", "latexname"], [6, 5, 1, "", "name"], [6, 4, 1, "", "scale"], [6, 3, 1, "", "set_display_name"], [6, 3, 1, "", "set_latex_name"], [6, 3, 1, "", "set_name"]], "unitSI.tests": [[9, 0, 0, "-", "test_units"]], "unitSI.tests.test_units": [[9, 6, 1, "", "assert_quantity"], [9, 6, 1, "", "test_addition_subtraction"], [9, 6, 1, "", "test_all_units_list"], [9, 6, 1, "", "test_arange_linspace"], [9, 6, 1, "", "test_binary_operations"], [9, 6, 1, "", "test_check_units"], [9, 6, 1, "", "test_constants"], [9, 6, 1, "", "test_construction"], [9, 6, 1, "", "test_deepcopy"], [9, 6, 1, "", "test_dimension_singletons"], [9, 6, 1, "", "test_display"], [9, 6, 1, "", "test_fail_for_dimension_mismatch"], [9, 6, 1, "", "test_format_quantity"], [9, 6, 1, "", "test_get_best_unit"], [9, 6, 1, "", "test_get_dimensions"], [9, 6, 1, "", "test_get_unit"], [9, 6, 1, "", "test_inplace_on_scalars"], [9, 6, 1, "", "test_inplace_operations"], [9, 6, 1, "", "test_list"], [9, 6, 1, "", "test_multiplication_division"], [9, 6, 1, "", "test_numpy_functions_change_dimensions"], [9, 6, 1, "", "test_numpy_functions_dimensionless"], [9, 6, 1, "", "test_numpy_functions_indices"], [9, 6, 1, "", "test_numpy_functions_logical"], [9, 6, 1, "", "test_numpy_functions_same_dimensions"], [9, 6, 1, "", "test_numpy_functions_typeerror"], [9, 6, 1, "", "test_pickling"], [9, 6, 1, "", "test_power"], [9, 6, 1, "", "test_setting"], [9, 6, 1, "", "test_slicing"], [9, 6, 1, "", "test_special_case_numpy_functions"], [9, 6, 1, "", "test_str_repr"], [9, 6, 1, "", "test_switching_off_unit_checks"], [9, 6, 1, "", "test_unary_operations"], [9, 6, 1, "", "test_unit_discarding_functions"], [9, 6, 1, "", "test_units_vs_quantities"], [9, 6, 1, "", "test_unitsafe_functions"]], "unitSI.unitsafefunctions": [[10, 6, 1, "", "arange"], [10, 6, 1, "", "arccos"], [10, 6, 1, "", "arccosh"], [10, 6, 1, "", "arcsin"], [10, 6, 1, "", "arcsinh"], [10, 6, 1, "", "arctan"], [10, 6, 1, "", "arctanh"], [10, 6, 1, "", "cos"], [10, 6, 1, "", "cosh"], [10, 6, 1, "", "diagonal"], [10, 6, 1, "", "dot"], [10, 6, 1, "", "exp"], [10, 6, 1, "", "expm1"], [10, 6, 1, "", "exprel"], [10, 6, 1, "", "linspace"], [10, 6, 1, "", "log"], [10, 6, 1, "", "log10"], [10, 6, 1, "", "log1p"], [10, 6, 1, "", "ones_like"], [10, 6, 1, "", "ptp"], [10, 6, 1, "", "ravel"], [10, 6, 1, "", "sin"], [10, 6, 1, "", "sinh"], [10, 6, 1, "", "tan"], [10, 6, 1, "", "tanh"], [10, 6, 1, "", "trace"], [10, 6, 1, "", "where"], [10, 6, 1, "", "zeros_like"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "exception", "Python exception"], "2": ["py", "class", "Python class"], "3": ["py", "method", "Python method"], "4": ["py", "attribute", "Python attribute"], "5": ["py", "property", "Python property"], "6": ["py", "function", "Python function"], "7": ["py", "data", "Python data"]}, "objtypes": {"0": "py:module", "1": "py:exception", "2": "py:class", "3": "py:method", "4": "py:attribute", "5": "py:property", "6": "py:function", "7": "py:data"}, "terms": {"": [0, 3, 5, 6, 10, 11], "0": [0, 3, 5, 6, 10, 11], "00": [3, 10], "00000000005e": [3, 10], "00000000e": [3, 6, 10], "000000082740371e": [3, 10], "00091094": 5, "001": [0, 3, 5, 6, 11], "00123456": [3, 6], "00j": [3, 10], "01": [3, 6], "016j": [3, 10], "022140857": [5, 11], "02214086e": 5, "025": [3, 6], "02512346": [3, 6], "04": [3, 6], "06": 5, "0j": [3, 10], "0x": [3, 10], "1": [0, 3, 5, 6, 10, 11], "10": [3, 5, 6, 10, 11], "100": [3, 10], "1000": [3, 6, 10], "10000": [3, 10], "10938356": [5, 11], "10th": [3, 10], "11": [3, 6, 10], "12": [3, 5, 6, 10, 11], "121": [3, 10], "122": [3, 10], "123": [3, 6], "12303177e": [3, 10], "123123": [3, 6], "123456": [3, 6], "126": [3, 10], "127": [3, 10], "128": [3, 10], "129": [3, 10], "13": [3, 10], "14159265": [3, 10], "15": [3, 5, 6, 10, 11], "16": [3, 10], "160": 5, "16j": [3, 10], "17": [3, 10], "18": [3, 6], "180": [3, 10], "19": [5, 11], "1964": [3, 10], "1972": [3, 10], "1d": [3, 6], "1e": [3, 10], "1j": [3, 10], "2": [0, 3, 5, 6, 10, 11], "20": [3, 10, 11], "20000": [3, 6], "2000000": [3, 6], "201": [3, 10], "21": [3, 6], "21766208": 5, "2246063538223773e": [3, 10], "22460635e": [3, 10], "23": [3, 5, 6, 11], "23456": [3, 6], "235": [3, 6], "24": [3, 6, 10], "25": [3, 6, 10], "25663706e": 5, "27": [3, 6, 11], "273": [5, 11], "2j": [3, 10], "3": [3, 5, 6, 10, 11], "30": [3, 10, 11], "3000": [3, 6], "31": [5, 11], "3144598": [5, 11], "32": [3, 10], "33289": [5, 11], "3361": [3, 10], "360": [3, 10], "38064852": [5, 11], "38064852e": 5, "3j": [3, 10], "4": [3, 6, 10], "40": [3, 10], "4001": [3, 10], "45": [3, 10], "4816": [3, 10], "499128": [3, 10], "5": [3, 6, 10, 11], "50": [3, 6, 10], "54930614": [3, 10], "566370614": [5, 11], "5707963267948966": [3, 10], "5969": [3, 10], "6": [3, 5, 6, 10, 11], "60": [3, 10], "6000": [3, 6], "6021766208": [5, 11], "6176": [3, 10], "625": [3, 10], "63317787e": [3, 10], "65745445": [3, 10], "6576": [3, 10], "67": [3, 10], "69": [3, 10], "7": [3, 5, 6, 10, 11], "70": [3, 10], "70710678": [3, 10], "718281": [3, 10], "7185": [3, 10], "72538256": [3, 10], "75": [3, 10], "7776": [3, 10], "78539816": [3, 10], "78539816339744828": [3, 10], "79": [3, 10], "79ff": [3, 10], "8": [3, 5, 10, 11], "80": [3, 10], "83": [3, 10], "854187817": [5, 11], "85418782e": 5, "86": [3, 10], "8660254": [3, 10], "8801": [3, 10], "9": [3, 5, 6, 10, 11], "90": [3, 10], "96485": [5, 11], "99": [3, 10], "99322285": [3, 10], "99822295": [3, 10], "A": [3, 4, 5, 6, 10, 11], "As": [0, 3, 10], "At": [3, 10], "BY": 4, "But": 0, "By": [3, 6, 10], "For": [0, 3, 6, 10, 11], "If": [3, 6, 10], "In": [0, 3, 6, 10], "It": [3, 6, 10], "Its": [3, 10], "NOT": 4, "Not": 0, "One": [3, 6], "The": [0, 3, 5, 6, 10], "Their": 11, "There": [0, 3, 6, 10, 11], "These": 0, "To": 11, "With": [3, 10], "__array_function__": [3, 10], "__init__": [3, 6, 11], "aand": [3, 10], "ab": [3, 6, 10], "abbrevi": 11, "about": [0, 3, 6, 10, 11], "abov": [0, 3, 6, 10], "abramovitz": [3, 10], "abramowitz": [3, 10], "abs_temp": 11, "absolut": [0, 3, 6, 11], "accept": [3, 6], "accordingli": [0, 11], "account": [3, 10], "accumul": [3, 10], "accur": [3, 10], "accuraci": [3, 10], "aco": [3, 10], "acronym": [3, 10], "across": [0, 3, 10], "act": [3, 6], "actual": [0, 3, 9, 10], "ad": [3, 10], "add": [0, 3, 6], "addit": [3, 6, 11], "additionali": 11, "adjac": [3, 10], "affect": [3, 10, 11], "again": [3, 6], "against": [3, 6, 10], "all": [0, 3, 6, 9, 10, 11], "alloc": [3, 10], "allow": [0, 3, 6, 10], "allunit": [3, 6, 11], "along": [3, 6, 10], "alreadi": [3, 10], "also": [0, 9, 11], "alter": [3, 10], "altern": [3, 10], "alwai": [0, 3, 6, 10], "amax": [3, 6], "amin": [3, 6], "among": [3, 6], "amp": [3, 5, 6, 11], "amper": [6, 11], "an": [0, 3, 6, 10, 11], "anaconda3": [3, 6], "analysi": 11, "analyt": [3, 10], "angl": [3, 10], "ani": [0, 3, 6, 9, 10, 11], "anoth": [3, 6, 10], "anti": [3, 10], "appear": 11, "append": [3, 10, 11], "appli": 0, "approach": [3, 10], "appropri": [0, 3, 6], "approxim": [3, 10], "ar": [0, 3, 5, 6, 10], "arang": [0, 3, 10], "arbitrari": [3, 6, 10], "arcco": [0, 3, 10], "arccosh": [0, 3, 10], "arcsin": [0, 3, 10], "arcsinh": [0, 3, 10], "arctan": [0, 3, 10], "arctan2": [0, 3, 10], "arctanh": [0, 3, 10], "area": [3, 6], "aren": [3, 6], "arg": [3, 6, 10], "argmax": [0, 3, 6], "argmin": [3, 6], "argsort": [0, 3, 6], "argument": [0, 3, 6, 10, 11], "arithmet": [3, 6, 10], "around": [0, 3, 6, 10], "arr": [3, 6, 10], "arrai": [0, 3, 6, 9, 10, 11], "array_lik": [3, 6, 10], "array_of_diagon": [3, 10], "asanyarrai": 0, "asarrai": [0, 3, 6, 10, 11], "asin": [3, 10], "asinh": [3, 10], "ask": [3, 6], "assert_quant": [8, 9], "assign": [3, 6], "associ": [3, 6], "assum": [3, 6], "assur": [3, 6, 9], "astyp": [0, 3, 10], "atan": [3, 10], "atanh": [3, 10], "attempt": [3, 6, 10], "atto": [3, 6], "attribut": 10, "au": [3, 6], "automat": [0, 3, 4, 6], "automatically_register_unit": [3, 6], "avail": [3, 5, 6], "averag": [3, 6], "avogadro": [5, 11], "avogadro_const": [3, 5, 11], "avoid": 11, "awai": 0, "awar": 10, "ax": [3, 10], "axi": [3, 6, 10], "axis1": [3, 6, 10], "axis2": [3, 6, 10], "b": [3, 10], "back": [3, 10], "backward": [3, 10], "base": [3, 6, 10, 11], "baseunit": [3, 6], "basic": [3, 6], "becaus": [0, 3, 6, 10, 11], "been": 11, "befor": [0, 3, 6, 10], "begin": [3, 10], "behav": [3, 6, 10], "behavior": [3, 10], "behaviour": [3, 10], "being": [3, 6, 10, 11], "below": [3, 6, 10, 11], "best": [3, 6], "better": [3, 10, 11], "between": [0, 3, 10], "bin": 5, "binari": 9, "biolog": 11, "bit": [3, 10], "bitwis": 0, "bitwise_and": 0, "bitwise_or": 0, "bitwise_xor": 0, "bla": [3, 10], "boltzmann": [5, 11], "boltzmann_const": [3, 5, 11], "bool": [3, 6, 10], "boolean": [0, 3, 6, 9], "both": [0, 3, 10], "branch": [3, 10], "brian": [0, 3, 5, 6, 11], "brian2": [3, 5, 6, 11], "broadcast": [3, 10], "buffer": [0, 3, 10], "bug": 0, "built": [3, 10], "builtin": 0, "c": [3, 5, 6, 10, 11], "c99": [3, 10], "ca": [3, 10], "cabl": [3, 10], "calcul": [0, 3, 6, 10, 11], "call": [0, 3, 6, 9, 10, 11], "can": [0, 3, 5, 6, 10, 11], "candela": 11, "candl": 6, "cannot": [0, 3, 6, 10, 11], "care": [0, 3, 6, 10], "case": [3, 6, 10, 11], "cast": [3, 6, 10], "catch": [3, 6], "cbm": [3, 10], "cd": 6, "ceil": [0, 3, 10], "celsiu": [5, 11], "celsius_temp": 11, "center": [3, 10], "centi": [3, 6, 11], "certain": [3, 6, 9], "cgi": 5, "chain": [3, 10], "chang": [3, 9, 10, 11], "charg": [5, 11], "check": [0, 3, 6, 9, 11], "check_unit": [3, 6, 9], "choic": 11, "choos": [0, 3, 10], "chosen": [3, 10], "circl": [3, 10], "clash": 11, "class": [3, 6, 10], "clear": 11, "clip": [0, 3, 6], "clockwis": [3, 10], "close": [3, 10], "cm": [3, 6, 7, 11], "cm2": 7, "cm3": 7, "cmap": [3, 10], "cmeter": 11, "cmetr": [3, 6, 11], "co": [0, 3, 10], "code": [3, 4, 6], "coeffici": 11, "collect": [3, 10], "column": [3, 10], "combin": [3, 6, 11], "come": [3, 10], "common": 11, "compar": [3, 6, 9], "comparison": 0, "compat": [3, 10, 11], "complain": 11, "complex": [3, 10], "compos": [3, 6], "compound": [3, 6], "compress": 0, "comput": [3, 10], "condit": [3, 10], "conduct": [3, 6], "conform": [3, 10], "confus": 11, "conj": 0, "conjug": [0, 3, 10], "consid": [0, 3, 10], "consist": [3, 6, 10, 11], "constant": [3, 6], "construct": 9, "contain": [3, 10], "content": 2, "contigu": [3, 10], "continu": [3, 10], "contrast": 11, "conveni": 11, "convent": [3, 10, 11], "convert": [0, 3, 6, 9], "coordin": [3, 10], "copi": [0, 3, 6, 10, 11], "copysign": 0, "corrcoeff": 0, "correct": [0, 3, 9, 10, 11], "correctli": [0, 3, 10, 11], "correl": 0, "correspond": [0, 3, 6, 10], "cosh": [0, 3, 10], "cosin": [3, 10], "could": [0, 3, 10], "coulomb": 11, "count": [3, 10], "counter": [3, 10], "counterpart": [0, 9], "coupl": [9, 11], "cov": 0, "cover": [3, 10], "creat": [3, 6, 10], "create_scaled_unit": [3, 6], "creation": [3, 10], "critic": [3, 6], "cross": 0, "cube": 11, "cumprod": [0, 3, 6], "cumsum": [0, 3, 6], "cumul": [3, 6], "current": [3, 6, 10], "cut": [3, 10], "cuu": 5, "d": [3, 6, 10], "da": [3, 6], "data": [0, 3, 10], "ddof": [3, 6], "deci": [3, 6], "decim": [3, 6], "declar": [3, 6], "decor": [3, 6, 9], "def": [3, 6], "default": [0, 3, 6, 10, 11], "defin": [0, 3, 6, 7, 10, 11], "definit": [0, 3, 6], "deg2rad": 0, "degre": [3, 5, 10], "deka": [3, 6], "delet": 0, "densiti": [3, 6], "depart": [3, 10], "depend": [3, 6, 10, 11], "deprec": [3, 6, 10], "deriv": [3, 6, 11], "describ": [3, 10], "descript": [3, 6], "desir": [3, 10], "destroi": [3, 6], "detail": [3, 6, 11], "determin": [3, 10], "dev": 4, "develop": 11, "deviat": [3, 6], "diag": [3, 10], "diagflat": [3, 10], "diagon": [0, 3, 6, 10], "did": 11, "diff": 0, "differ": [0, 9, 11], "digit": [0, 3, 6, 10], "dim": [3, 6], "dimens": [0, 3, 6, 9, 10], "dimension": [3, 10, 11], "dimensionless": [0, 3, 6, 9], "dimensionmismatcherror": [0, 3, 6, 9, 11], "directli": [0, 3, 10, 11], "disappear": 0, "discard": 9, "discrep": [3, 10], "displai": [3, 6, 9], "dispnam": [3, 6], "distanc": [3, 10], "distinct": [0, 3, 6], "divid": [0, 11], "divis": [3, 6], "do": [0, 3, 4, 6, 9, 11], "doc": [3, 10], "document": [3, 6, 10, 11], "doe": [0, 3, 6, 9, 10], "domain": [3, 10], "don": [3, 6, 10], "dot": [0, 3, 6, 10], "dover": [3, 10], "dt": 11, "dtype": [3, 6, 10], "due": [3, 10], "dump": 0, "dure": 11, "dv": 11, "e": [0, 3, 5, 6, 10, 11], "each": [3, 6, 10], "earlier": 11, "edit": 4, "effici": [3, 6], "einstein": [3, 10], "einsum": [3, 10], "either": [0, 3, 6, 10], "electr": [3, 5, 6, 11], "electric_const": [3, 5, 11], "electron": [5, 11], "electron_mass": [3, 5, 11], "element": [0, 3, 6, 10], "elementari": [5, 11], "elementary_charg": [3, 5, 11], "els": [3, 6, 10], "elsewher": [3, 10], "emath": [3, 10], "empti": [3, 6, 10], "empty_lik": [3, 10], "en": [3, 10], "end": [3, 10], "endpoint": [3, 10], "enforc": 0, "ensur": [3, 10], "entri": 0, "ep0": 5, "epsilon_0": [5, 11], "equal": [0, 3, 10], "equat": 11, "equival": [3, 6, 10], "error": [0, 3, 6, 9, 10, 11], "etc": [0, 3, 6, 10], "euler": [3, 10], "eval": 9, "evalu": [0, 3, 6, 10], "even": [0, 3, 10, 11], "evenli": [3, 10], "everi": [3, 6], "everyth": [0, 11], "exa": [3, 6], "exact": [3, 10], "exactli": [3, 10], "exampl": [0, 11], "except": [0, 3, 6, 10, 11], "exclud": [3, 10], "exist": [3, 6], "exp": [0, 3, 10], "exp2": [0, 3, 10], "expect": [3, 6, 10, 11], "experi": 11, "explicitli": [3, 5, 6, 10, 11], "expm1": [0, 3, 10], "expon": [0, 3, 6], "exponenti": [3, 10], "exponential_funct": [3, 10], "exprel": [3, 10], "express": [0, 3, 6, 10, 11], "extent": [3, 10], "extern": 9, "extobj": [3, 10], "ey": [3, 10], "f": [3, 5, 6, 10, 11], "fact": [3, 10, 11], "factor": [3, 6, 11], "fail": [3, 6], "fail_for_dimension_mismatch": 9, "fals": [3, 6, 10], "farad": [3, 5, 6, 11], "faradai": [5, 11], "faraday_const": [3, 5, 11], "fastest": [3, 10], "featur": [3, 10], "femto": [3, 6], "file": [3, 4, 10], "fill": [0, 3, 6, 10], "find": [3, 6, 10], "first": [3, 6, 10], "fit": [3, 6], "fix": [3, 10], "flag": [3, 10], "flat": [3, 6, 10], "flatten": [0, 3, 6, 10], "flexibl": [3, 10], "flip": [3, 10], "fliplr": [0, 3, 10], "flipud": [0, 3, 10], "float": [0, 3, 6, 10], "floor": 0, "floor_divid": 0, "fmod": 0, "follow": [3, 6, 7], "forbidden": 0, "forc": [3, 6], "force_quant": [3, 6], "form": [3, 6, 10], "former": [3, 10], "formula": [3, 10], "fortran": [3, 10], "found": [3, 6], "four": [3, 10], "frac": 11, "freshli": [3, 10], "frexp": 0, "from": [0, 3, 5, 6, 9, 10, 11], "full": [3, 6], "full_lik": [3, 10], "fullfil": 9, "function": [3, 6, 9, 10, 11], "fundament": [3, 10], "fundamentalunit": 3, "further": 0, "futur": [3, 6, 10], "futurewarn": [3, 10], "g": [0, 3, 5, 6, 10, 11], "ga": [5, 11], "gas_const": [3, 5, 11], "gave": 11, "gener": [3, 4, 6, 9, 10, 11], "geometr": [3, 10], "geomspac": [3, 10], "get": [3, 6, 9, 10, 11], "get_best_unit": [3, 6], "get_dimens": [3, 6], "get_or_create_dimens": [3, 6], "get_printopt": [3, 6], "get_unit": [3, 6, 9], "getfield": 0, "getvoltag": [3, 6], "giga": [3, 6], "give": [0, 11], "given": [3, 6, 10], "goldman": 11, "got": [3, 6, 11], "gov": 5, "grai": [3, 10], "gram": 11, "gramm": 11, "graph": [3, 10], "graphic": [3, 10], "greater": [0, 3, 10], "greater_equ": 0, "grid": [3, 10], "h": [3, 6], "ha": [3, 6, 10, 11], "had": 11, "half": [3, 10], "hand": [3, 4, 6], "handbook": [3, 10], "handl": [3, 10], "hang": [3, 10], "has_same_dimens": [3, 6], "have": [0, 3, 5, 6, 10, 11], "have_same_dimens": [3, 6], "header": [3, 6], "hecto": [3, 6], "hello": [3, 6], "help": [3, 6], "henri": 5, "here": [3, 6, 10], "hertz": 11, "histogram": 0, "histogram2d": 0, "histogramdd": 0, "hodgkin": 11, "hold": [3, 10], "home": [3, 6], "horizont": [3, 10], "how": [3, 10, 11], "howev": [3, 10, 11], "hsv": [3, 10], "htm": [3, 10], "http": [3, 5, 10], "human": [3, 6], "hyperbol": [3, 10], "hyperbolic_funct": [3, 10], "hypot": 0, "hz": [7, 11], "i": [0, 3, 4, 6, 10, 11], "ib": [3, 10], "ident": 11, "ignor": [0, 3, 10], "illustr": [3, 10], "imagin": [3, 6], "imaginari": [3, 10], "implement": [3, 6, 10], "impli": [3, 10], "implicitli": 0, "import": [3, 5, 6, 10], "imshow": [3, 10], "in_best_unit": [3, 6], "in_unit": [3, 6], "includ": [0, 3, 10, 11], "inconsist": [3, 6], "incorrect": [3, 6, 10, 11], "independ": [3, 10], "index": [1, 3, 10], "indic": [3, 6, 9], "inf": [0, 3, 10], "infer": [3, 10], "infin": [3, 10], "infinit": [3, 10], "infinitesim": [3, 10], "infj": [3, 10], "inform": [3, 6, 10], "initi": [3, 6], "inner": [0, 3, 10], "input": [0, 3, 6, 10], "insert": [0, 3, 6, 10], "instanc": [3, 10], "instead": [0, 3, 4, 6, 10, 11], "int": [0, 3, 6, 10], "int16": [3, 10], "int32": [3, 10], "int64": [3, 10], "int8": [3, 10], "integ": [0, 3, 6, 10], "intern": [0, 3, 10], "interpret": [3, 6], "intersect": [3, 10], "interv": [3, 10], "introductori": 11, "invalid": [3, 10], "invers": [3, 10], "invert": 0, "involv": [0, 3, 6], "irrat": [3, 10], "is_dimensionless": [3, 6], "is_high": [3, 6], "is_scalar_typ": [3, 6], "iscomplex": 0, "iscompound": [3, 6], "isfinit": 0, "isinf": 0, "isnan": 0, "isreal": 0, "issu": [3, 10], "item": [0, 3, 6], "itemset": 0, "iter": [3, 6, 10], "its": [0, 3, 6, 10, 11], "itself": 0, "j": [3, 5, 10, 11], "joul": [3, 5, 6, 11], "just": [3, 6, 10], "k": [3, 5, 6, 10, 11], "katz": 11, "keep": [3, 6, 10], "keepdim": [3, 6, 10], "kelvin": [5, 6, 11], "keyword": [3, 6, 10], "kg": [3, 5, 6, 11], "kgram": 11, "khz": 7, "kilo": [3, 6], "kilogram": [3, 5, 6, 11], "kilogramm": 11, "kind": [3, 6, 10], "know": [3, 6], "known": [3, 10], "kwarg": [3, 6, 10], "kwd": [3, 6, 10], "l": [3, 5, 6, 11], "lambda": [3, 6], "larg": [3, 6, 10], "larger": [3, 10], "last": [0, 3, 6, 10, 11], "latex": [3, 6, 9], "latexnam": [3, 6], "latter": [3, 6, 10], "layout": [3, 10], "ldexp": 0, "lead": [0, 3, 10], "left": [3, 6, 10], "left_shift": 0, "length": [3, 6, 10], "length\u00b2": [3, 6], "less": [0, 3, 10], "less_equ": 0, "letter": 11, "li": [3, 10], "lib": [3, 6], "librari": [3, 10], "like": [0, 3, 6, 10], "limit": [3, 6], "linalg": [0, 3, 10], "line": [3, 10], "line2d": [3, 10], "linspac": [0, 3, 10], "list": [0, 3, 6, 9], "liter": 11, "litr": 11, "ln": [3, 10], "locat": [3, 10], "log": [0, 3, 10], "log10": [0, 3, 10], "log1p": [0, 3, 10], "log2": [0, 3, 10], "log_": [3, 10], "logaddexp": 0, "logaddexp2": 0, "logarithm": [3, 10], "logic": [0, 9], "logical_and": 0, "logical_not": 0, "logical_or": 0, "logical_xor": 0, "logspac": [3, 10], "longer": 0, "loss": [3, 10], "lumen": 11, "luminos": [3, 6], "m": [3, 5, 6, 7, 10, 11], "m_e": [5, 11], "m_u": [5, 11], "ma": 7, "made": [0, 3, 10], "magnet": [5, 11], "magnetic_const": [3, 5, 11], "magnitud": [3, 10], "mai": [3, 10], "main": [0, 3, 10], "maintain": [3, 6, 10], "major": [3, 10, 11], "make": [0, 3, 10], "mamp": [3, 6], "mani": [0, 3, 10], "mask": [3, 10], "mass": [3, 5, 6, 11], "match": [0, 3, 6, 10, 11], "math": [0, 3, 6, 10], "mathemat": [0, 3, 10], "mathrm": [5, 11], "matlab": [3, 10], "matmul": [3, 10], "matplotlib": [3, 6, 10], "matric": [3, 10], "matrix": [3, 10], "max": [0, 3, 6], "maximum": [0, 3, 6, 10], "me": 5, "mean": [0, 3, 6, 10, 11], "measur": [3, 10, 11], "mega": [3, 6], "membran": [3, 6], "memori": [3, 10], "mention": [0, 11], "met": [3, 10], "meter": 11, "method": [9, 10], "metr": [3, 5, 6, 11], "mf": 7, "mgrid": [3, 10], "mhz": 7, "mi": [3, 10], "micro": [3, 6], "micro_amp": 7, "middl": [3, 10], "might": [0, 3, 10], "milli": [3, 6], "min": [0, 3, 6], "minimum": [0, 3, 6, 10], "minu": [3, 10], "misinterpret": 11, "mismatch": [0, 11], "mm": [7, 11], "mm2": 7, "mm3": 7, "mmetr": [3, 6], "mmolar": 11, "mod": 0, "mode": [3, 6], "model": 11, "modf": 0, "modul": [1, 2], "modulo": [3, 10], "mol": [5, 6, 11], "molar": [5, 11], "molar_mass_const": [3, 5, 11], "mole": [5, 6, 11], "more": [3, 6, 10, 11], "most": [0, 3, 6, 10, 11], "msecond": [3, 6, 11], "msiemen": 11, "mu": [3, 5, 6], "mu0": 5, "mu_0": [5, 11], "much": [3, 10], "multi": [3, 10], "multi_dot": [3, 10], "multidimension": [3, 10], "multipl": [0, 3, 6, 10, 11], "multipli": [0, 3, 10, 11], "multiplicand": [3, 6], "multiply_sum": [3, 6], "multivalu": [3, 10], "must": [3, 6, 10], "mv": [0, 3, 6, 7, 11], "mvolt": [3, 6, 11], "n": [3, 5, 6, 7, 10, 11], "n_a": [5, 11], "na": [3, 5, 6, 7], "name": [3, 5, 6, 7, 10, 11], "nan": [3, 10], "nano": [3, 6], "natur": [3, 10], "ndarrai": [3, 6, 10], "ndim": [3, 10], "necessari": [3, 6, 10], "need": [3, 6, 9, 10], "neg": [0, 3, 10], "neither": [3, 10], "nest": [3, 6], "neurongroup": 11, "never": [0, 3, 10, 11], "new": [3, 6, 10, 11], "newaxi": [3, 10], "newbyteord": 0, "newli": [3, 10], "newton": [3, 6], "nextaft": 0, "nf": 7, "nice": [3, 6], "nist": 5, "nm": [3, 6], "non": [0, 3, 6, 10, 11], "none": [3, 6, 10], "nonzero": [0, 3, 6, 10], "nor": [3, 10], "normal": [3, 6, 11], "not_equ": 0, "note": [0, 5, 11], "now": [3, 6, 10], "np": [0, 3, 6, 10], "nsiemen": 11, "num": [3, 10], "number": [3, 6, 10, 11], "numer": [3, 10], "numpi": [3, 6, 9, 10, 11], "ny": [3, 10], "o": [3, 10], "obj": [3, 6], "obj1": [3, 6], "obj2": [3, 6], "object": [0, 3, 5, 6, 9, 10, 11], "obtain": [3, 10], "occur": [3, 10], "off": [3, 9, 10], "offset": [3, 6, 10], "often": [0, 3, 10], "ogrid": [3, 10], "ohm": [3, 6, 11], "old": [3, 10], "omega": [3, 6], "omit": [3, 10], "onc": [3, 6], "one": [0, 3, 6, 10, 11], "ones": [3, 10], "ones_lik": [0, 3, 10], "onli": [0, 3, 6, 9, 10, 11], "op": [3, 6], "open": [3, 10], "oper": [0, 3, 6, 9, 10], "operand": [3, 10], "opposit": [3, 10], "optim": [3, 10], "option": [0, 3, 6, 7, 10, 11], "order": [3, 6, 10], "org": [3, 10], "origin": [3, 6, 10], "other": [0, 3, 6, 10, 11], "otherwis": [3, 6, 10], "out": [3, 6, 10], "out1": [3, 10], "out2": [3, 10], "outer": [0, 3, 10], "outgo": [3, 10], "output": [3, 10], "over": [3, 6, 10], "overflow": [3, 10], "overrid": [3, 6, 10], "overwritten": [0, 3, 6, 11], "own": [0, 3, 6], "p": [3, 6, 10, 11], "pa": 7, "pack": [3, 10], "packag": [1, 2, 6, 11], "page": 1, "page_67": [3, 10], "page_69": [3, 10], "page_79": [3, 10], "page_83": [3, 10], "page_86": [3, 10], "pair": [3, 6], "paragraph": 11, "part": [3, 10], "particular": [3, 10], "partit": [3, 10], "pascal": 11, "pass": [3, 6, 10], "past": [3, 10], "peak": [3, 6, 10], "perform": [3, 6, 10], "period": [3, 10], "permut": 0, "person": [3, 10], "peta": [3, 6], "pfarad": [3, 6], "pg": [3, 10], "phase": [3, 10], "physic": [3, 5, 6], "pi": [3, 10], "pickl": [0, 9], "pico": [3, 6], "place": [3, 10], "plane": [3, 10], "plot": [3, 10], "plt": [3, 10], "plu": [3, 10], "point": [3, 10, 11], "popul": [3, 10], "posit": [3, 10], "possibl": [3, 6, 10, 11], "possibli": [3, 6], "power": [0, 3, 9, 10], "pp": [3, 10], "precis": [3, 6, 10], "predefin": [3, 6, 11], "prefer": [3, 10], "prefix": [3, 6, 11], "preserv": [3, 10], "previou": [3, 6], "print": [3, 6, 10, 11], "prior": [3, 10], "prod": [0, 3, 6], "produc": [3, 10], "product": [3, 6, 10], "progress": [3, 10], "propag": 0, "proper": [3, 6], "properti": [3, 6, 10], "protocol": [3, 10], "provid": [0, 3, 5, 6, 10, 11], "provis": [3, 10], "ptp": [0, 3, 6, 10], "pure": [0, 11], "purpos": [0, 3, 6], "put": [0, 3, 6], "pwatt": [3, 6], "py": [0, 3, 4, 6], "pylab": [3, 10], "pyplot": [3, 10], "python": [0, 3, 6, 10, 11], "python3": [3, 6], "python_cod": [3, 6], "q": [3, 6, 9, 11], "q10": 11, "quadrant": [3, 10], "quantit": 11, "quantiti": [0, 3, 5, 6, 9], "question": 0, "quickest": [3, 10], "quit": 0, "r": [3, 5, 6, 11], "rad": [3, 10], "rad2deg": 0, "radian": [3, 10], "radiu": [3, 10], "rai": [3, 10], "rais": [0, 9, 11], "random": 0, "rang": [3, 10, 11], "rare": [3, 6], "rate": 11, "rather": [3, 10], "ravel": [0, 3, 6, 10], "read": [3, 6, 10], "readabl": [3, 6], "real": [3, 10], "reason": 0, "reattach": 0, "recent": [0, 3, 6, 10, 11], "reciproc": 0, "recommend": 11, "reduc": [3, 10], "reduct": [3, 10], "refer": 6, "referenc": 11, "reg": [3, 6], "regist": [3, 6], "register_new_unit": [3, 6], "registri": [3, 6], "relat": [3, 10], "releas": [3, 10], "relev": [3, 10], "remain": [3, 10], "remaind": 0, "remov": [0, 3, 6, 10], "repeat": [0, 11], "replac": [3, 6, 10], "report": 11, "repr": 9, "repres": [3, 6], "represent": [3, 6, 9], "reshap": [0, 3, 10], "resiz": 0, "respect": [0, 3, 6], "rest": [3, 5, 10], "restrict": [3, 6], "result": [0, 3, 6, 9, 10, 11], "retain": [3, 6, 10], "retriev": [3, 10], "retstep": [3, 10], "return": [0, 9, 11], "revers": [3, 10], "rid": [3, 6], "right": [3, 10], "right_shift": 0, "rint": 0, "roll": 0, "rot90": 0, "roughli": [3, 10], "round": [0, 3, 6, 10], "row": [3, 10], "rt": 11, "rule": [3, 6, 10, 11], "said": [3, 10], "same": [0, 3, 6, 10, 11], "same_kind": [3, 10], "sampl": [3, 10], "save": 0, "scalar": [0, 3, 6, 10, 11], "scale": [3, 6, 10, 11], "scalefactor": [3, 6], "search": [1, 3, 6], "searchsort": [0, 3, 6], "second": [0, 3, 5, 6, 10, 11], "section": [3, 10], "see": 11, "seem": 0, "sens": 0, "sequenc": [3, 6, 10], "set": [3, 6, 10, 11], "set_display_nam": [3, 6], "set_latex_nam": [3, 6], "set_nam": [3, 6], "setasflat": 0, "setfield": 0, "setflag": 0, "sever": [3, 6], "shape": [0, 3, 10], "short": 7, "shorter": [5, 11], "shorthand": [3, 10], "should": [0, 3, 6, 9, 10], "show": [3, 6, 10], "shown": [3, 10], "shuffl": 0, "si": [3, 6, 11], "side": [3, 6], "siemen": 11, "siemens2": 11, "sign": [0, 3, 6, 10], "signatur": [3, 6, 10], "signbit": 0, "signific": [3, 10], "similar": [3, 6, 10], "simplic": 0, "sin": [0, 3, 10], "sinc": [3, 6, 11], "sine": [3, 10], "singl": [3, 6, 10], "sinh": [0, 3, 10], "site": [3, 6], "size": [3, 10], "skip": [3, 10], "slightli": [3, 6], "slowest": [3, 10], "small": [3, 10], "so": [3, 6, 10], "some": [0, 3, 5, 6, 9, 10, 11], "someth": 0, "sorin": [3, 6], "sort": [0, 3, 6], "sorter": [3, 6], "sourc": [0, 3, 6, 9, 10], "space": [3, 10], "special": [3, 6, 9, 10], "specif": [3, 10], "specifi": [3, 6, 10, 11], "sqrt": 0, "squar": [0, 3, 6, 11], "squeez": 0, "stabil": [3, 10], "stabl": [3, 10], "standard": [0, 3, 6, 10, 11], "start": [0, 3, 10], "state": [3, 6, 11], "static": [3, 4, 6], "static_codegen": 4, "std": [0, 3, 6], "stdin": [3, 10], "stdunit": [3, 6], "stegun": [3, 10], "step": [3, 10], "still": [3, 10], "stop": [3, 10], "store": [3, 10], "str": [3, 6, 9], "strict": [3, 6], "stride": [3, 10], "string": [3, 6], "strip": 0, "studi": [3, 10], "style": [3, 10], "sub": [3, 10], "subclass": [3, 10], "submodul": 2, "subok": [3, 10], "subpackag": [0, 2], "subplot": [3, 10], "substanc": [3, 6], "subtract": 0, "subtyp": [3, 10], "suggest": [3, 10], "sum": [0, 3, 6, 10], "sum_along_diagon": [3, 10], "summand_1": [3, 6], "summand_2": [3, 6], "summat": [3, 10], "superior": [3, 10], "support": [0, 3, 10, 11], "swapax": [3, 10], "switch": 9, "symbol": [5, 6, 11], "sympi": 9, "syntax": 11, "system": [3, 11], "t": [3, 6, 10, 11], "tabl": [3, 10], "take": [0, 3, 6, 10], "taken": [0, 3, 10], "tan": [0, 3, 10], "tangent": [3, 10], "tanh": [0, 3, 10], "tau": 11, "tell": [3, 6], "temperatur": [3, 6], "templat": 4, "tensordot": [3, 10], "tera": [3, 6], "term": [3, 10], "test": [3, 6], "test_addition_subtract": [8, 9], "test_all_units_list": [8, 9], "test_arange_linspac": [8, 9], "test_binary_oper": [8, 9], "test_check_unit": [8, 9], "test_const": [8, 9], "test_construct": [8, 9], "test_deepcopi": [8, 9], "test_dimension_singleton": [8, 9], "test_displai": [8, 9], "test_fail_for_dimension_mismatch": [8, 9], "test_format_quant": [8, 9], "test_get_best_unit": [8, 9], "test_get_dimens": [8, 9], "test_get_unit": [8, 9], "test_inplace_on_scalar": [8, 9], "test_inplace_oper": [8, 9], "test_list": [8, 9], "test_multiplication_divis": [8, 9], "test_numpy_functions_change_dimens": [8, 9], "test_numpy_functions_dimensionless": [8, 9], "test_numpy_functions_indic": [8, 9], "test_numpy_functions_log": [8, 9], "test_numpy_functions_same_dimens": [8, 9], "test_numpy_functions_typeerror": [8, 9], "test_pickl": [8, 9], "test_pow": [8, 9], "test_set": [8, 9], "test_slic": [8, 9], "test_special_case_numpy_funct": [8, 9], "test_str_repr": [8, 9], "test_switching_off_unit_check": [8, 9], "test_unary_oper": [8, 9], "test_unit": 8, "test_unit_discarding_funct": [8, 9], "test_units_vs_quant": [8, 9], "test_unitsafe_funct": [8, 9], "text": [3, 10], "than": [3, 6, 10], "thei": [0, 3, 5, 6, 9, 10, 11], "them": [3, 5, 6, 11], "therefor": [0, 3, 6, 10, 11], "thi": [0, 3, 4, 6, 7, 10, 11], "thin": 0, "thing": [3, 6], "though": [0, 11], "three": [3, 10], "through": [3, 10], "throw": 0, "tight": [3, 10], "time": [3, 5, 6, 11], "time\u00b2": [3, 6], "titl": [3, 10], "tofil": 0, "togeth": [3, 10, 11], "tolist": [0, 3, 6], "too": [3, 10], "tool": 4, "tostr": 0, "total": [3, 6], "toward": [3, 10], "trace": [0, 3, 6, 10], "traceback": [0, 3, 6, 10, 11], "track": [3, 6], "transform": 11, "transpos": 0, "treat": 0, "treatment": 9, "triangl": [3, 10], "trigonometr": [0, 3, 10], "trigonometri": [3, 10], "trim_zero": 0, "true": [0, 3, 6, 10], "true_divid": 0, "trunc": 0, "try": [0, 3, 10], "tupl": [3, 10], "turn": [3, 6], "two": [3, 6, 10, 11], "type": [0, 3, 6, 10], "typeerror": [0, 3, 6, 9], "typic": 11, "u": [3, 6, 7, 11], "ua": [3, 6, 7], "ubc": [3, 10], "uf": 7, "ufunc": [3, 10], "ugli": [3, 6], "uint8": [3, 10], "um": [3, 6, 7], "um2": 7, "um3": 7, "unchang": [0, 3, 10], "underli": [3, 10, 11], "underscor": 11, "unexpect": [3, 10], "uniniti": [3, 10], "unit": [3, 5, 6, 7, 9, 10], "unitless": [0, 3, 6, 9, 11], "unitregistri": [3, 6], "units_templ": 4, "unitsaf": 9, "unitsafefunct": [0, 3], "unless": [3, 10], "unpack": [3, 6], "unscal": [3, 6], "unsign": [3, 10], "unsupport": 0, "us": [0, 3, 5, 6, 9, 10], "use_matplotlib_units_fix": [3, 6], "user": [3, 6], "usiemen": [3, 6], "usiemens3": 11, "v": [0, 3, 6, 11], "v_": 11, "vagari": [3, 10], "valid": [3, 6], "valu": [0, 3, 5, 6, 9, 10, 11], "valueerror": [0, 3, 10], "var": [0, 3, 6], "vari": [3, 10], "variabl": [3, 6, 11], "varianc": [3, 6], "variou": [3, 6, 9, 11], "vdot": [3, 10], "vector": [3, 10, 11], "veri": [3, 6, 10], "version": [0, 3, 6, 10, 11], "vertic": [3, 10], "via": [3, 9, 10], "view": [0, 3, 6, 10], "viewpoint": 0, "volt": [3, 6, 11], "voltag": [3, 6, 11], "wa": [3, 6, 10, 11], "wai": [0, 3, 6, 9, 11], "watt": 11, "we": [3, 10], "well": [0, 11], "were": [0, 3, 6], "what": [3, 6, 10], "when": [0, 3, 6, 9, 10], "where": [0, 3, 6, 10], "wherea": 0, "whether": [3, 6, 9, 10, 11], "which": [0, 3, 6, 10, 11], "while": [3, 6, 10, 11], "whose": [3, 6, 10], "wibbl": [3, 6], "width": [3, 10], "wiki": [3, 10], "wikipedia": [3, 10], "wildcard": 5, "wise": [0, 3, 10], "with_dimens": [3, 6], "within": [3, 10], "without": [0, 3, 10], "won": [3, 10], "word": [3, 10], "work": [0, 3, 9, 10, 11], "worri": [3, 6], "would": [0, 3, 6, 10], "wrap": [0, 9], "wrap_function_dimensionless": 0, "wrap_function_keep_dimens": 0, "wrapper": 0, "write": [3, 6, 10], "wrong": [0, 3, 6], "wsl": [3, 6], "x": [3, 6, 9, 10, 11], "x1": [3, 10], "x2": [3, 10], "xlabel": [3, 10], "xv": [3, 10], "xx": [3, 10], "y": [3, 6, 10, 11], "yet": 0, "ygram": 5, "yield": [3, 10], "ylabel": [3, 10], "ylim": [3, 10], "ylumen3": 11, "ymol": 11, "yocto": [3, 6, 11], "york": [3, 10], "yotta": [3, 6, 11], "you": [0, 3, 5, 6, 10, 11], "your": [3, 6, 10], "yv": [3, 10], "z": [3, 6, 10], "zcoulomb": 5, "zepto": [3, 6], "zero": [0, 3, 5, 6, 10, 11], "zero_celsiu": [3, 5, 11], "zeros_lik": [3, 10], "zetta": [3, 6], "zip": [3, 10]}, "titles": ["Units", "Welcome to unitSI\u2019s documentation!", "unitSI", "unitSI package", "unitSI.allunits module", "unitSI.constants module", "unitSI.fundamentalunits module", "unitSI.stdunits module", "unitSI.tests package", "unitSI.tests.test_units module", "unitSI.unitsafefunctions module", "Physical units"], "titleterms": {"": 1, "In": 11, "The": 11, "allunit": 4, "also": [3, 6, 10], "ar": 11, "attribut": [3, 6], "beginn": 11, "cast": 0, "constant": [5, 11], "content": [1, 3, 8], "document": 1, "essenti": 11, "exampl": [3, 6, 10], "follow": 11, "function": 0, "fundamentalunit": 6, "import": 11, "indic": 1, "method": [0, 3, 6], "modul": [3, 4, 5, 6, 7, 8, 9, 10], "ndarrai": 0, "note": [3, 6, 10], "numpi": 0, "oper": 11, "packag": [3, 8], "paramet": [3, 6, 10], "physic": 11, "place": 11, "quantiti": 11, "rais": [3, 6, 10], "refer": [3, 10], "remov": 11, "return": [3, 6, 10], "rule": 0, "see": [3, 6, 10], "stdunit": 7, "submodul": [3, 8], "subpackag": 3, "tabl": 1, "temperatur": 11, "test": [8, 9], "test_unit": 9, "topic": 11, "ufunc": 0, "unit": [0, 11], "unitsafefunct": 10, "unitsi": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "us": 11, "warn": [3, 10], "welcom": 1}})
\ No newline at end of file
+Search.setIndex({"alltitles": {"Attributes": [[6, "attributes"]], "Casting rules": [[0, "casting-rules"]], "Constants": [[11, "constants"]], "Contents:": [[1, null]], "Examples": [[6, "examples"], [6, "id11"], [6, "id17"], [6, "id21"], [6, "id40"], [6, "id45"], [6, "id50"], [6, "id58"], [6, "id62"], [6, "id69"], [10, "examples"], [10, "id6"], [10, "id16"], [10, "id24"], [10, "id33"], [10, "id41"], [10, "id51"], [10, "id58"], [10, "id63"], [10, "id67"], [10, "id72"], [10, "id82"], [10, "id89"], [10, "id93"], [10, "id103"], [10, "id113"], [10, "id123"], [10, "id127"], [10, "id130"], [10, "id135"], [10, "id142"], [10, "id149"], [10, "id156"], [10, "id165"], [10, "id169"], [10, "id174"], [10, "id178"]], "Functions and units": [[0, "functions-and-units"]], "Importing units": [[11, "importing-units"]], "In-place operations on quantities": [[11, "in-place-operations-on-quantities"]], "Indices and tables": [[1, "indices-and-tables"]], "Methods": [[6, "methods"]], "Module contents": [[3, "module-contents"], [8, "module-unitSI.tests"]], "Notes": [[6, "notes"], [6, "id46"], [6, "id51"], [10, "notes"], [10, "id12"], [10, "id22"], [10, "id29"], [10, "id39"], [10, "id47"], [10, "id56"], [10, "id78"], [10, "id88"], [10, "id99"], [10, "id109"], [10, "id119"], [10, "id134"], [10, "id141"], [10, "id147"], [10, "id154"], [10, "id161"], [10, "id173"]], "Numpy functions": [[0, "numpy-functions"]], "Numpy ufuncs": [[0, "numpy-ufuncs"]], "Parameters": [[6, "parameters"], [6, "id10"], [6, "id12"], [6, "id13"], [6, "id15"], [6, "id19"], [6, "id38"], [6, "id41"], [6, "id43"], [6, "id47"], [6, "id49"], [6, "id52"], [6, "id54"], [6, "id56"], [6, "id60"], [6, "id64"], [6, "id66"], [6, "id68"], [10, "parameters"], [10, "id1"], [10, "id7"], [10, "id17"], [10, "id25"], [10, "id34"], [10, "id42"], [10, "id52"], [10, "id59"], [10, "id64"], [10, "id68"], [10, "id73"], [10, "id83"], [10, "id90"], [10, "id94"], [10, "id104"], [10, "id114"], [10, "id124"], [10, "id128"], [10, "id131"], [10, "id136"], [10, "id143"], [10, "id150"], [10, "id157"], [10, "id166"], [10, "id170"], [10, "id175"]], "Physical units": [[11, "physical-units"]], "Raises": [[6, "raises"], [10, "raises"], [10, "id70"]], "References": [[10, "references"], [10, "id13"], [10, "id23"], [10, "id30"], [10, "id40"], [10, "id48"], [10, "id57"], [10, "id79"], [10, "id100"], [10, "id110"], [10, "id120"], [10, "id148"], [10, "id155"], [10, "id162"]], "Removing units": [[11, "removing-units"]], "Returns": [[6, "returns"], [6, "id14"], [6, "id16"], [6, "id20"], [6, "id35"], [6, "id39"], [6, "id42"], [6, "id44"], [6, "id48"], [6, "id53"], [6, "id55"], [6, "id57"], [6, "id61"], [6, "id65"], [6, "id67"], [10, "returns"], [10, "id4"], [10, "id10"], [10, "id20"], [10, "id28"], [10, "id37"], [10, "id45"], [10, "id55"], [10, "id62"], [10, "id65"], [10, "id69"], [10, "id76"], [10, "id86"], [10, "id91"], [10, "id97"], [10, "id107"], [10, "id117"], [10, "id125"], [10, "id129"], [10, "id132"], [10, "id139"], [10, "id146"], [10, "id153"], [10, "id160"], [10, "id167"], [10, "id171"], [10, "id176"]], "See Also": [[6, "id1"], [6, "id2"], [6, "id3"], [6, "id4"], [6, "id5"], [6, "id6"], [6, "id7"], [6, "id8"], [6, "id9"], [6, "id18"], [6, "id22"], [6, "id23"], [6, "id24"], [6, "id25"], [6, "id26"], [6, "id27"], [6, "id28"], [6, "id29"], [6, "id30"], [6, "id31"], [6, "id32"], [6, "id33"], [6, "id34"], [6, "id36"], [6, "id37"], [6, "id59"], [6, "id63"], [10, "see-also"], [10, "id5"], [10, "id11"], [10, "id21"], [10, "id38"], [10, "id46"], [10, "id66"], [10, "id71"], [10, "id77"], [10, "id87"], [10, "id92"], [10, "id98"], [10, "id108"], [10, "id118"], [10, "id126"], [10, "id133"], [10, "id140"], [10, "id168"], [10, "id172"], [10, "id177"]], "See also": [[6, "see-also"]], "Submodules": [[3, "submodules"], [8, "submodules"]], "Subpackages": [[3, "subpackages"]], "Temperatures": [[11, "temperatures"]], "The following topics are not essential for beginners.": [[11, null]], "Units": [[0, "units"]], "Using units": [[11, "using-units"]], "Warnings": [[10, "warnings"]], "Welcome to unitSI\u2019s documentation!": [[1, "welcome-to-unitsi-s-documentation"]], "ndarray methods": [[0, "ndarray-methods"]], "unitSI": [[2, "unitsi"]], "unitSI package": [[3, "unitsi-package"]], "unitSI.allunits module": [[4, "module-unitSI.allunits"]], "unitSI.constants module": [[5, "module-unitSI.constants"]], "unitSI.fundamentalunits module": [[6, "module-unitSI.fundamentalunits"]], "unitSI.stdunits module": [[7, "module-unitSI.stdunits"]], "unitSI.tests package": [[8, "unitsi-tests-package"]], "unitSI.tests.test_units module": [[9, "module-unitSI.tests.test_units"]], "unitSI.unitsafefunctions module": [[10, "module-unitSI.unitsafefunctions"]]}, "docnames": ["developer/units", "index", "modules", "unitSI", "unitSI.allunits", "unitSI.constants", "unitSI.fundamentalunits", "unitSI.stdunits", "unitSI.tests", "unitSI.tests.test_units", "unitSI.unitsafefunctions", "user/units"], "envversion": {"sphinx": 61, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1}, "filenames": ["developer/units.rst", "index.rst", "modules.rst", "unitSI.rst", "unitSI.allunits.rst", "unitSI.constants.rst", "unitSI.fundamentalunits.rst", "unitSI.stdunits.rst", "unitSI.tests.rst", "unitSI.tests.test_units.rst", "unitSI.unitsafefunctions.rst", "user/units.rst"], "indexentries": {}, "objects": {"unitSI": [[4, 0, 0, "-", "allunits"], [5, 0, 0, "-", "constants"], [6, 0, 0, "-", "fundamentalunits"], [7, 0, 0, "-", "stdunits"], [8, 0, 0, "-", "tests"], [10, 0, 0, "-", "unitsafefunctions"]], "unitSI.constants": [[5, 1, 1, "", "avogadro_constant"], [5, 1, 1, "", "boltzmann_constant"], [5, 1, 1, "", "electric_constant"], [5, 1, 1, "", "electron_mass"], [5, 1, 1, "", "elementary_charge"], [5, 1, 1, "", "faraday_constant"], [5, 1, 1, "", "gas_constant"], [5, 1, 1, "", "magnetic_constant"], [5, 1, 1, "", "molar_mass_constant"], [5, 1, 1, "", "zero_celsius"]], "unitSI.fundamentalunits": [[6, 2, 1, "", "DimensionMismatchError"], [6, 3, 1, "", "Quantity"], [6, 3, 1, "", "Unit"], [6, 7, 1, "", "check_units"], [6, 7, 1, "", "get_dimensions"], [6, 7, 1, "", "get_or_create_dimension"], [6, 7, 1, "", "get_unit"], [6, 7, 1, "", "have_same_dimensions"], [6, 7, 1, "", "in_best_unit"], [6, 7, 1, "", "in_unit"], [6, 7, 1, "", "is_dimensionless"], [6, 7, 1, "", "is_scalar_type"], [6, 7, 1, "", "register_new_unit"]], "unitSI.fundamentalunits.Quantity": [[6, 4, 1, "", "all"], [6, 4, 1, "", "any"], [6, 4, 1, "", "argmax"], [6, 4, 1, "", "argmin"], [6, 4, 1, "", "argsort"], [6, 4, 1, "", "clip"], [6, 4, 1, "", "cumprod"], [6, 4, 1, "", "cumsum"], [6, 4, 1, "", "diagonal"], [6, 5, 1, "", "dim"], [6, 6, 1, "", "dimensions"], [6, 4, 1, "", "dot"], [6, 4, 1, "", "fill"], [6, 4, 1, "", "get_best_unit"], [6, 4, 1, "", "has_same_dimensions"], [6, 4, 1, "", "in_best_unit"], [6, 4, 1, "", "in_unit"], [6, 6, 1, "", "is_dimensionless"], [6, 4, 1, "", "item"], [6, 5, 1, "", "matplotlib"], [6, 4, 1, "", "max"], [6, 4, 1, "", "mean"], [6, 4, 1, "", "min"], [6, 4, 1, "", "nonzero"], [6, 4, 1, "", "prod"], [6, 4, 1, "", "ptp"], [6, 4, 1, "", "put"], [6, 4, 1, "", "ravel"], [6, 4, 1, "", "round"], [6, 4, 1, "", "searchsorted"], [6, 4, 1, "", "std"], [6, 4, 1, "", "sum"], [6, 4, 1, "", "tolist"], [6, 4, 1, "", "trace"], [6, 5, 1, "", "use_matplotlib_units_fix"], [6, 4, 1, "", "var"], [6, 4, 1, "", "with_dimensions"]], "unitSI.fundamentalunits.Unit": [[6, 5, 1, "", "automatically_register_units"], [6, 4, 1, "", "create"], [6, 4, 1, "", "create_scaled_unit"], [6, 5, 1, "", "dim"], [6, 6, 1, "", "dispname"], [6, 5, 1, "", "iscompound"], [6, 6, 1, "", "latexname"], [6, 6, 1, "", "name"], [6, 5, 1, "", "scale"], [6, 4, 1, "", "set_display_name"], [6, 4, 1, "", "set_latex_name"], [6, 4, 1, "", "set_name"]], "unitSI.tests": [[9, 0, 0, "-", "test_units"]], "unitSI.tests.test_units": [[9, 7, 1, "", "assert_quantity"], [9, 7, 1, "", "test_addition_subtraction"], [9, 7, 1, "", "test_all_units_list"], [9, 7, 1, "", "test_arange_linspace"], [9, 7, 1, "", "test_binary_operations"], [9, 7, 1, "", "test_check_units"], [9, 7, 1, "", "test_constants"], [9, 7, 1, "", "test_construction"], [9, 7, 1, "", "test_deepcopy"], [9, 7, 1, "", "test_dimension_singletons"], [9, 7, 1, "", "test_display"], [9, 7, 1, "", "test_fail_for_dimension_mismatch"], [9, 7, 1, "", "test_format_quantity"], [9, 7, 1, "", "test_get_best_unit"], [9, 7, 1, "", "test_get_dimensions"], [9, 7, 1, "", "test_get_unit"], [9, 7, 1, "", "test_inplace_on_scalars"], [9, 7, 1, "", "test_inplace_operations"], [9, 7, 1, "", "test_list"], [9, 7, 1, "", "test_multiplication_division"], [9, 7, 1, "", "test_numpy_functions_change_dimensions"], [9, 7, 1, "", "test_numpy_functions_dimensionless"], [9, 7, 1, "", "test_numpy_functions_indices"], [9, 7, 1, "", "test_numpy_functions_logical"], [9, 7, 1, "", "test_numpy_functions_same_dimensions"], [9, 7, 1, "", "test_numpy_functions_typeerror"], [9, 7, 1, "", "test_pickling"], [9, 7, 1, "", "test_power"], [9, 7, 1, "", "test_setting"], [9, 7, 1, "", "test_slicing"], [9, 7, 1, "", "test_special_case_numpy_functions"], [9, 7, 1, "", "test_str_repr"], [9, 7, 1, "", "test_switching_off_unit_checks"], [9, 7, 1, "", "test_unary_operations"], [9, 7, 1, "", "test_unit_discarding_functions"], [9, 7, 1, "", "test_units_vs_quantities"], [9, 7, 1, "", "test_unitsafe_functions"]], "unitSI.unitsafefunctions": [[10, 7, 1, "", "arange"], [10, 7, 1, "", "arccos"], [10, 7, 1, "", "arccosh"], [10, 7, 1, "", "arcsin"], [10, 7, 1, "", "arcsinh"], [10, 7, 1, "", "arctan"], [10, 7, 1, "", "arctanh"], [10, 7, 1, "", "cos"], [10, 7, 1, "", "cosh"], [10, 7, 1, "", "diagonal"], [10, 7, 1, "", "dot"], [10, 7, 1, "", "exp"], [10, 7, 1, "", "expm1"], [10, 7, 1, "", "exprel"], [10, 7, 1, "", "linspace"], [10, 7, 1, "", "log"], [10, 7, 1, "", "log10"], [10, 7, 1, "", "log1p"], [10, 7, 1, "", "ones_like"], [10, 7, 1, "", "ptp"], [10, 7, 1, "", "ravel"], [10, 7, 1, "", "sin"], [10, 7, 1, "", "sinh"], [10, 7, 1, "", "tan"], [10, 7, 1, "", "tanh"], [10, 7, 1, "", "trace"], [10, 7, 1, "", "where"], [10, 7, 1, "", "zeros_like"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "data", "Python data"], "2": ["py", "exception", "Python exception"], "3": ["py", "class", "Python class"], "4": ["py", "method", "Python method"], "5": ["py", "attribute", "Python attribute"], "6": ["py", "property", "Python property"], "7": ["py", "function", "Python function"]}, "objtypes": {"0": "py:module", "1": "py:data", "2": "py:exception", "3": "py:class", "4": "py:method", "5": "py:attribute", "6": "py:property", "7": "py:function"}, "terms": {"": [0, 5, 6, 10, 11], "0": [0, 5, 6, 10, 11], "00": 10, "00000000005e": 10, "00000000e": [6, 10], "000000082740371e": 10, "00091094": 5, "001": [5, 6, 11], "00123456": 6, "00j": 10, "01": 6, "016j": 10, "022140857": [5, 11], "02214086e": 5, "025": 6, "02512346": 6, "04": 6, "06": 5, "0j": 10, "0x": 10, "1": [0, 5, 6, 10, 11], "10": [5, 6, 10, 11], "100": 10, "1000": [6, 10], "10000": 10, "10938356": [5, 11], "10th": 10, "11": [6, 10], "12": [5, 6, 10, 11], "121": 10, "122": 10, "123": 6, "12303177e": 10, "123123": 6, "123456": 6, "126": 10, "127": 10, "128": 10, "129": 10, "13": 10, "14159265": 10, "15": [5, 6, 10, 11], "16": 10, "160": 5, "16j": 10, "17": 10, "18": 6, "180": 10, "19": [5, 11], "1964": 10, "1972": 10, "1d": 6, "1e": 10, "1j": 10, "2": [0, 5, 6, 10, 11], "20": [10, 11], "20000": 6, "2000000": 6, "201": 10, "21": 6, "21766208": 5, "2246063538223773e": 10, "22460635e": 10, "23": [5, 6, 11], "23456": 6, "235": 6, "24": [6, 10], "25": [6, 10], "25663706e": 5, "27": [6, 11], "273": [5, 11], "2j": 10, "3": [5, 6, 10, 11], "30": [10, 11], "3000": 6, "31": [5, 11], "3144598": [5, 11], "32": 10, "33289": [5, 11], "3361": 10, "360": 10, "38064852": [5, 11], "38064852e": 5, "3j": 10, "4": [6, 10], "40": 10, "4001": 10, "45": 10, "4816": 10, "499128": 10, "5": [6, 10, 11], "50": [6, 10], "54930614": 10, "566370614": [5, 11], "5707963267948966": 10, "5969": 10, "6": [5, 6, 10, 11], "60": 10, "6000": 6, "6021766208": [5, 11], "6176": 10, "625": 10, "63317787e": 10, "65745445": 10, "6576": 10, "67": 10, "69": 10, "7": [5, 6, 10, 11], "70": 10, "70710678": 10, "718281": 10, "7185": 10, "72538256": 10, "75": 10, "7776": 10, "78539816": 10, "78539816339744828": 10, "79": 10, "79ff": 10, "8": [5, 10, 11], "80": 10, "83": 10, "854187817": [5, 11], "85418782e": 5, "86": 10, "8660254": 10, "8801": 10, "9": [5, 6, 10, 11], "90": 10, "96485": [5, 11], "99": 10, "99322285": 10, "99822295": 10, "A": [4, 5, 6, 10, 11], "As": [0, 10], "At": 10, "BY": 4, "But": 0, "By": [6, 10], "For": [0, 6, 10, 11], "If": [6, 10], "In": [1, 6, 10], "It": [6, 10], "Its": 10, "NOT": 4, "Not": 0, "One": 6, "The": [0, 5, 6, 10], "Their": 11, "There": [0, 6, 10, 11], "These": 0, "To": 11, "With": 10, "__array_function__": 10, "__init__": [6, 11], "aand": 10, "ab": [6, 10], "abbrevi": 11, "about": [0, 6, 10, 11], "abov": [0, 6, 10], "abramovitz": 10, "abramowitz": 10, "abs_temp": 11, "absolut": [0, 6, 11], "accept": 6, "accordingli": 11, "account": 10, "accumul": 10, "accur": 10, "accuraci": 10, "aco": 10, "acronym": 10, "across": [0, 10], "act": 6, "actual": [0, 9, 10], "ad": 10, "add": [0, 6], "addit": [6, 11], "additionali": 11, "adjac": 10, "affect": [10, 11], "again": 6, "against": [6, 10], "all": [0, 6, 9, 10, 11], "alloc": 10, "allow": [0, 6, 10], "allunit": [3, 6, 11], "along": [6, 10], "alreadi": 10, "also": [0, 9, 11], "alter": 10, "altern": 10, "alwai": [0, 6, 10], "amax": 6, "amin": 6, "among": 6, "amp": [5, 6, 11], "amper": [6, 11], "an": [0, 6, 10, 11], "anaconda3": 6, "analysi": 11, "analyt": 10, "angl": 10, "ani": [0, 6, 9, 10, 11], "anoth": [6, 10], "anti": 10, "appear": 11, "append": [10, 11], "appli": 0, "approach": 10, "appropri": [0, 6], "approxim": 10, "ar": [0, 5, 6, 10], "arang": [0, 3, 10], "arbitrari": [6, 10], "arcco": [0, 3, 10], "arccosh": [0, 3, 10], "arcsin": [0, 3, 10], "arcsinh": [0, 3, 10], "arctan": [0, 3, 10], "arctan2": [0, 10], "arctanh": [0, 3, 10], "area": 6, "aren": 6, "arg": [6, 10], "argmax": [0, 6], "argmin": 6, "argsort": [0, 6], "argument": [0, 6, 10, 11], "arithmet": [6, 10], "around": [0, 6, 10], "arr": [6, 10], "arrai": [0, 6, 9, 10, 11], "array_lik": [6, 10], "array_of_diagon": 10, "asanyarrai": 0, "asarrai": [0, 6, 10, 11], "asin": 10, "asinh": 10, "ask": 6, "assert_quant": [8, 9], "assign": 6, "associ": 6, "assum": 6, "assur": [6, 9], "astyp": [0, 10], "atan": 10, "atanh": 10, "attempt": [6, 10], "atto": 6, "attribut": 10, "au": 6, "automat": [0, 4, 6], "automatically_register_unit": 6, "avail": [5, 6], "averag": 6, "avogadro": [5, 11], "avogadro_const": [3, 5, 11], "avoid": 11, "awai": 0, "awar": 10, "ax": 10, "axi": [6, 10], "axis1": [6, 10], "axis2": [6, 10], "b": 10, "back": 10, "backward": 10, "base": [6, 10, 11], "baseunit": 6, "basic": 6, "becaus": [0, 6, 10, 11], "been": 11, "befor": [0, 6, 10], "begin": 10, "behav": [6, 10], "behavior": 10, "behaviour": 10, "being": [6, 10, 11], "below": [6, 10, 11], "best": 6, "better": [10, 11], "between": 10, "bin": 5, "binari": 9, "biolog": 11, "bit": 10, "bitwis": 0, "bitwise_and": 0, "bitwise_or": 0, "bitwise_xor": 0, "bla": 10, "boltzmann": [5, 11], "boltzmann_const": [3, 5, 11], "bool": [6, 10], "boolean": [0, 6, 9], "both": [0, 10], "branch": 10, "brian": [5, 6, 11], "brian2": [5, 6, 11], "broadcast": 10, "buffer": [0, 10], "bug": 0, "built": 10, "builtin": 0, "c": [5, 6, 10, 11], "c99": 10, "ca": 10, "cabl": 10, "calcul": [0, 6, 10, 11], "call": [0, 6, 9, 10, 11], "can": [0, 5, 6, 10, 11], "candela": 11, "candl": 6, "cannot": [0, 6, 10, 11], "care": [0, 6, 10], "case": [6, 10, 11], "cast": [1, 6, 10], "catch": 6, "cbm": 10, "cd": 6, "ceil": [0, 10], "celsiu": [5, 11], "celsius_temp": 11, "center": 10, "centi": [6, 11], "certain": [6, 9], "cgi": 5, "chain": 10, "chang": [9, 10, 11], "charg": [5, 11], "check": [0, 6, 9, 11], "check_unit": [3, 6, 9], "choic": 11, "choos": [0, 10], "chosen": 10, "circl": 10, "clash": 11, "class": [6, 10], "clear": 11, "clip": [0, 6], "clockwis": 10, "close": 10, "cm": [6, 7, 11], "cm2": 7, "cm3": 7, "cmap": 10, "cmeter": 11, "cmetr": [6, 11], "co": [0, 3, 10], "code": [4, 6], "coeffici": 11, "collect": 10, "column": 10, "combin": [6, 11], "come": 10, "common": 11, "compar": [6, 9], "comparison": 0, "compat": [10, 11], "complain": 11, "complex": 10, "compos": 6, "compound": 6, "compress": 0, "comput": 10, "condit": 10, "conduct": 6, "conform": 10, "confus": 11, "conj": 0, "conjug": [0, 10], "consid": [0, 10], "consist": [6, 10, 11], "constant": [1, 3, 6], "construct": 9, "contain": 10, "content": 2, "contigu": 10, "continu": 10, "contrast": 11, "conveni": 11, "convent": [10, 11], "convert": [0, 6, 9], "coordin": 10, "copi": [0, 6, 10, 11], "copysign": 0, "corrcoeff": 0, "correct": [0, 9, 10, 11], "correctli": [0, 10, 11], "correl": 0, "correspond": [0, 6, 10], "cosh": [0, 3, 10], "cosin": 10, "could": 10, "coulomb": 11, "count": 10, "counter": 10, "counterpart": [0, 9], "coupl": [9, 11], "cov": 0, "cover": 10, "creat": [6, 10], "create_scaled_unit": 6, "creation": 10, "critic": 6, "cross": 0, "cube": 11, "cumprod": [0, 6], "cumsum": [0, 6], "cumul": 6, "current": [6, 10], "cut": 10, "cuu": 5, "d": [6, 10], "da": 6, "data": [0, 10], "ddof": 6, "deci": 6, "decim": 6, "declar": 6, "decor": [6, 9], "def": 6, "default": [0, 6, 10, 11], "defin": [0, 6, 7, 10, 11], "definit": [0, 6], "deg2rad": 0, "degre": [5, 10], "deka": 6, "delet": 0, "densiti": 6, "depart": 10, "depend": [6, 10, 11], "deprec": [6, 10], "deriv": [6, 11], "describ": 10, "descript": 6, "desir": 10, "destroi": 6, "detail": [6, 11], "determin": 10, "dev": 4, "develop": 11, "deviat": 6, "diag": 10, "diagflat": 10, "diagon": [0, 3, 6, 10], "did": 11, "diff": 0, "differ": [0, 9, 11], "digit": [0, 6, 10], "dim": 6, "dimens": [0, 6, 9, 10], "dimension": [10, 11], "dimensionless": [0, 6, 9], "dimensionmismatcherror": [0, 3, 6, 9, 11], "directli": [0, 10, 11], "disappear": 0, "discard": 9, "discrep": 10, "displai": [6, 9], "dispnam": 6, "distanc": 10, "distinct": 6, "divid": [0, 11], "divis": 6, "do": [0, 4, 6, 9, 11], "doc": 10, "document": [6, 10, 11], "doe": [0, 6, 9, 10], "domain": 10, "don": [6, 10], "dot": [0, 3, 6, 10], "dover": 10, "dt": 11, "dtype": [6, 10], "due": 10, "dump": 0, "dure": 11, "dv": 11, "e": [0, 5, 6, 10, 11], "each": [6, 10], "earlier": 11, "edit": 4, "effici": 6, "einstein": 10, "einsum": 10, "either": [0, 6, 10], "electr": [5, 6, 11], "electric_const": [3, 5, 11], "electron": [5, 11], "electron_mass": [3, 5, 11], "element": [0, 6, 10], "elementari": [5, 11], "elementary_charg": [3, 5, 11], "els": [6, 10], "elsewher": 10, "emath": 10, "empti": [6, 10], "empty_lik": 10, "en": 10, "end": 10, "endpoint": 10, "enforc": 0, "ensur": 10, "entri": 0, "ep0": 5, "epsilon_0": [5, 11], "equal": [0, 10], "equat": 11, "equival": [6, 10], "error": [0, 6, 9, 10, 11], "etc": [0, 6, 10], "euler": 10, "eval": 9, "evalu": [0, 6, 10], "even": [0, 10, 11], "evenli": 10, "everi": 6, "everyth": [0, 11], "exa": 6, "exact": 10, "exactli": 10, "exampl": [0, 11], "except": [0, 6, 10, 11], "exclud": 10, "exist": 6, "exp": [0, 3, 10], "exp2": [0, 10], "expect": [6, 10, 11], "experi": 11, "explicitli": [5, 6, 10, 11], "expm1": [0, 3, 10], "expon": [0, 6], "exponenti": 10, "exponential_funct": 10, "exprel": [3, 10], "express": [0, 6, 10, 11], "extent": 10, "extern": 9, "extobj": 10, "ey": 10, "f": [5, 6, 10, 11], "fact": [10, 11], "factor": [6, 11], "fail": 6, "fail_for_dimension_mismatch": 9, "fals": [6, 10], "farad": [5, 6, 11], "faradai": [5, 11], "faraday_const": [3, 5, 11], "fastest": 10, "featur": 10, "femto": 6, "file": [4, 10], "fill": [0, 6, 10], "find": [6, 10], "first": [6, 10], "fit": 6, "fix": 10, "flag": 10, "flat": [6, 10], "flatten": [0, 6, 10], "flexibl": 10, "flip": 10, "fliplr": [0, 10], "flipud": [0, 10], "float": [0, 6, 10], "floor": 0, "floor_divid": 0, "fmod": 0, "follow": [6, 7], "forbidden": 0, "forc": 6, "force_quant": 6, "form": [6, 10], "former": 10, "formula": 10, "fortran": 10, "found": 6, "four": 10, "frac": 11, "freshli": 10, "frexp": 0, "from": [0, 5, 6, 9, 10, 11], "full": 6, "full_lik": 10, "fullfil": 9, "function": [1, 6, 9, 10, 11], "fundament": 10, "fundamentalunit": 3, "further": 0, "futur": [6, 10], "futurewarn": 10, "g": [0, 5, 6, 10, 11], "ga": [5, 11], "gas_const": [3, 5, 11], "gave": 11, "gener": [4, 6, 9, 10, 11], "geometr": 10, "geomspac": 10, "get": [6, 9, 10, 11], "get_best_unit": 6, "get_dimens": [3, 6], "get_or_create_dimens": [3, 6], "get_printopt": 6, "get_unit": [3, 6, 9], "getfield": 0, "getvoltag": 6, "giga": 6, "give": [0, 11], "given": [6, 10], "goldman": 11, "got": [6, 11], "gov": 5, "grai": 10, "gram": 11, "gramm": 11, "graph": 10, "graphic": 10, "greater": [0, 10], "greater_equ": 0, "grid": 10, "h": 6, "ha": [6, 10, 11], "had": 11, "half": 10, "hand": [4, 6], "handbook": 10, "handl": 10, "hang": 10, "has_same_dimens": 6, "have": [0, 5, 6, 10, 11], "have_same_dimens": [3, 6], "header": 6, "hecto": 6, "hello": 6, "help": 6, "henri": 5, "here": [6, 10], "hertz": 11, "histogram": 0, "histogram2d": 0, "histogramdd": 0, "hodgkin": 11, "hold": 10, "home": 6, "horizont": 10, "how": [10, 11], "howev": [10, 11], "hsv": 10, "htm": 10, "http": [5, 10], "human": 6, "hyperbol": 10, "hyperbolic_funct": 10, "hypot": 0, "hz": [7, 11], "i": [0, 4, 6, 10, 11], "ib": 10, "ident": 11, "ignor": [0, 10], "illustr": 10, "imagin": 6, "imaginari": 10, "implement": [6, 10], "impli": 10, "implicitli": 0, "import": [1, 5, 6, 10], "imshow": 10, "in_best_unit": [3, 6], "in_unit": [3, 6], "includ": [0, 10, 11], "inconsist": 6, "incorrect": [6, 10, 11], "independ": 10, "index": [1, 10], "indic": [6, 9], "inf": [0, 10], "infer": 10, "infin": 10, "infinit": 10, "infinitesim": 10, "infj": 10, "inform": [6, 10], "initi": 6, "inner": [0, 10], "input": [0, 6, 10], "insert": [0, 6, 10], "instanc": 10, "instead": [0, 4, 6, 10, 11], "int": [0, 6, 10], "int16": 10, "int32": 10, "int64": 10, "int8": 10, "integ": [0, 6, 10], "intern": [0, 10], "interpret": 6, "intersect": 10, "interv": 10, "introductori": 11, "invalid": 10, "invers": 10, "invert": 0, "involv": [0, 6], "irrat": 10, "is_dimensionless": [3, 6], "is_high": 6, "is_scalar_typ": [3, 6], "iscomplex": 0, "iscompound": 6, "isfinit": 0, "isinf": 0, "isnan": 0, "isreal": 0, "issu": 10, "item": [0, 6], "itemset": 0, "iter": [6, 10], "its": [0, 6, 10, 11], "itself": 0, "j": [5, 10, 11], "joul": [5, 6, 11], "just": [6, 10], "k": [5, 6, 10, 11], "katz": 11, "keep": [6, 10], "keepdim": [6, 10], "kelvin": [5, 6, 11], "keyword": [6, 10], "kg": [5, 6, 11], "kgram": 11, "khz": 7, "kilo": 6, "kilogram": [5, 6, 11], "kilogramm": 11, "kind": [6, 10], "know": 6, "known": 10, "kwarg": [6, 10], "kwd": [6, 10], "l": [5, 6, 11], "lambda": 6, "larg": [6, 10], "larger": 10, "last": [0, 6, 10, 11], "latex": [6, 9], "latexnam": 6, "latter": [6, 10], "layout": 10, "ldexp": 0, "lead": [0, 10], "left": [6, 10], "left_shift": 0, "length": [6, 10], "length\u00b2": 6, "less": [0, 10], "less_equ": 0, "letter": 11, "li": 10, "lib": 6, "librari": 10, "like": [0, 6, 10], "limit": 6, "linalg": [0, 10], "line": 10, "line2d": 10, "linspac": [0, 3, 10], "list": [0, 6, 9], "liter": 11, "litr": 11, "ln": 10, "locat": 10, "log": [0, 3, 10], "log10": [0, 3, 10], "log1p": [0, 3, 10], "log2": [0, 10], "log_": 10, "logaddexp": 0, "logaddexp2": 0, "logarithm": 10, "logic": [0, 9], "logical_and": 0, "logical_not": 0, "logical_or": 0, "logical_xor": 0, "logspac": 10, "longer": [], "loss": 10, "lumen": 11, "luminos": 6, "m": [5, 6, 7, 10, 11], "m_e": [5, 11], "m_u": [5, 11], "ma": 7, "made": 10, "magnet": [5, 11], "magnetic_const": [3, 5, 11], "magnitud": 10, "mai": 10, "main": [0, 10], "maintain": [6, 10], "major": [10, 11], "make": [0, 10], "mamp": 6, "mani": [0, 10], "mask": 10, "mass": [5, 6, 11], "match": [0, 6, 10, 11], "math": [0, 6, 10], "mathemat": [0, 10], "mathrm": [5, 11], "matlab": 10, "matmul": 10, "matplotlib": [6, 10], "matric": 10, "matrix": 10, "max": [0, 6], "maximum": [0, 6, 10], "me": 5, "mean": [0, 6, 10, 11], "measur": [10, 11], "mega": 6, "membran": 6, "memori": 10, "mention": [0, 11], "met": 10, "meter": 11, "method": [9, 10], "metr": [5, 6, 11], "mf": 7, "mgrid": 10, "mhz": 7, "mi": 10, "micro": 6, "micro_amp": 7, "middl": 10, "might": [0, 10], "milli": 6, "min": [0, 6], "minimum": [0, 6, 10], "minu": 10, "misinterpret": 11, "mismatch": [0, 11], "mm": [7, 11], "mm2": 7, "mm3": 7, "mmetr": 6, "mmolar": 11, "mod": 0, "mode": 6, "model": 11, "modf": 0, "modul": [1, 2], "modulo": 10, "mol": [5, 6, 11], "molar": [5, 11], "molar_mass_const": [3, 5, 11], "mole": [5, 6, 11], "more": [6, 10, 11], "most": [0, 6, 10, 11], "msecond": [6, 11], "msiemen": 11, "mu": [5, 6], "mu0": 5, "mu_0": [5, 11], "much": 10, "multi": 10, "multi_dot": 10, "multidimension": 10, "multipl": [6, 10, 11], "multipli": [0, 10, 11], "multiplicand": 6, "multiply_sum": 6, "multivalu": 10, "must": [6, 10], "mv": [0, 6, 7, 11], "mvolt": [6, 11], "n": [5, 6, 7, 10, 11], "n_a": [5, 11], "na": [5, 6, 7], "name": [5, 6, 7, 10, 11], "nan": 10, "nano": 6, "natur": 10, "ndarrai": [6, 10], "ndim": 10, "necessari": [6, 10], "need": [6, 9, 10], "neg": [0, 10], "neither": 10, "nest": 6, "neurongroup": 11, "never": [0, 10, 11], "new": [6, 10, 11], "newaxi": 10, "newbyteord": 0, "newli": 10, "newton": 6, "nextaft": 0, "nf": 7, "nice": 6, "nist": 5, "nm": 6, "non": [0, 6, 10, 11], "none": [6, 10], "nonzero": [0, 6, 10], "nor": 10, "normal": [6, 11], "not_equ": 0, "note": [0, 5, 11], "now": [6, 10], "np": [0, 6, 10], "nsiemen": 11, "num": 10, "number": [6, 10, 11], "numer": 10, "numpi": [6, 9, 10, 11], "ny": 10, "o": 10, "obj": 6, "obj1": 6, "obj2": 6, "object": [5, 6, 9, 10, 11], "obtain": 10, "occur": 10, "off": [9, 10], "offset": [6, 10], "often": [0, 10], "ogrid": 10, "ohm": [6, 11], "old": 10, "omega": 6, "omit": 10, "onc": 6, "one": [0, 6, 10, 11], "ones": 10, "ones_lik": [0, 3, 10], "onli": [0, 6, 9, 10, 11], "op": 6, "open": 10, "oper": [0, 1, 6, 9, 10], "operand": 10, "opposit": 10, "optim": 10, "option": [0, 6, 7, 10, 11], "order": [6, 10], "org": 10, "origin": [6, 10], "other": [0, 6, 10, 11], "otherwis": [6, 10], "out": [6, 10], "out1": 10, "out2": 10, "outer": [0, 10], "outgo": 10, "output": 10, "over": [6, 10], "overflow": 10, "overrid": [6, 10], "overwritten": [0, 6, 11], "own": [0, 6], "p": [6, 10, 11], "pa": 7, "pack": 10, "packag": [1, 2, 6, 11], "page": 1, "page_67": 10, "page_69": 10, "page_79": 10, "page_83": 10, "page_86": 10, "pair": 6, "paragraph": 11, "part": 10, "particular": 10, "partit": 10, "pascal": 11, "pass": [6, 10], "past": 10, "peak": [6, 10], "perform": [6, 10], "period": 10, "permut": 0, "person": 10, "peta": 6, "pfarad": 6, "pg": 10, "phase": 10, "physic": [1, 5, 6], "pi": 10, "pickl": [0, 9], "pico": 6, "place": [1, 10], "plane": 10, "plot": 10, "plt": 10, "plu": 10, "point": [10, 11], "popul": 10, "posit": 10, "possibl": [6, 10, 11], "possibli": 6, "power": [0, 9, 10], "pp": 10, "precis": [6, 10], "predefin": [6, 11], "prefer": 10, "prefix": [6, 11], "preserv": 10, "previou": 6, "print": [6, 10, 11], "prior": 10, "prod": [0, 6], "produc": 10, "product": [6, 10], "progress": 10, "propag": 0, "proper": 6, "properti": [6, 10], "protocol": 10, "provid": [0, 5, 6, 10, 11], "provis": 10, "ptp": [0, 3, 6, 10], "pure": [0, 11], "purpos": 6, "put": [0, 6], "pwatt": 6, "py": [0, 4, 6], "pylab": 10, "pyplot": 10, "python": [0, 6, 10, 11], "python3": 6, "python_cod": 6, "q": [6, 9, 11], "q10": 11, "quadrant": 10, "quantit": 11, "quantiti": [0, 1, 3, 5, 6, 9], "question": 0, "quickest": 10, "quit": 0, "r": [5, 6, 11], "rad": 10, "rad2deg": 0, "radian": 10, "radiu": 10, "rai": 10, "rais": [0, 9, 11], "random": 0, "rang": [10, 11], "rare": 6, "rate": 11, "rather": 10, "ravel": [0, 3, 6, 10], "read": [6, 10], "readabl": 6, "real": 10, "reason": 0, "reattach": 0, "recent": [0, 6, 10, 11], "reciproc": 0, "recommend": 11, "reduc": 10, "reduct": 10, "refer": 6, "referenc": 11, "reg": 6, "regist": 6, "register_new_unit": [3, 6], "registri": 6, "relat": 10, "releas": 10, "relev": 10, "remain": 10, "remaind": 0, "remov": [0, 1, 6, 10], "repeat": [0, 11], "replac": [6, 10], "report": 11, "repr": 9, "repres": 6, "represent": [6, 9], "reshap": [0, 10], "resiz": 0, "respect": [0, 6], "rest": [5, 10], "restrict": 6, "result": [0, 6, 9, 10, 11], "retain": [6, 10], "retriev": 10, "retstep": 10, "return": [0, 9, 11], "revers": 10, "rid": 6, "right": 10, "right_shift": 0, "rint": 0, "roll": 0, "rot90": 0, "roughli": 10, "round": [0, 6, 10], "row": 10, "rt": 11, "rule": [1, 6, 10, 11], "said": 10, "same": [0, 6, 10, 11], "same_kind": 10, "sampl": 10, "save": 0, "scalar": [0, 6, 10, 11], "scale": [6, 10, 11], "scalefactor": 6, "search": [1, 6], "searchsort": [0, 6], "second": [0, 5, 6, 10, 11], "section": 10, "see": 11, "seem": 0, "sens": 0, "sequenc": [6, 10], "set": [6, 10, 11], "set_display_nam": 6, "set_latex_nam": 6, "set_nam": 6, "setasflat": 0, "setfield": 0, "setflag": 0, "sever": 6, "shape": [0, 10], "short": 7, "shorter": [5, 11], "shorthand": 10, "should": [0, 6, 9, 10], "show": [6, 10], "shown": 10, "shuffl": 0, "si": [6, 11], "side": 6, "siemen": 11, "siemens2": 11, "sign": [0, 6, 10], "signatur": [6, 10], "signbit": 0, "signific": 10, "similar": [6, 10], "simplic": 0, "sin": [0, 3, 10], "sinc": [6, 11], "sine": 10, "singl": [6, 10], "sinh": [0, 3, 10], "site": 6, "size": 10, "skip": 10, "slightli": 6, "slowest": 10, "small": 10, "so": [6, 10], "some": [0, 5, 6, 9, 10, 11], "someth": 0, "sorin": 6, "sort": [0, 6], "sorter": 6, "sourc": [0, 6, 9, 10], "space": 10, "special": [6, 9, 10], "specif": 10, "specifi": [6, 10, 11], "sqrt": 0, "squar": [0, 6, 11], "squeez": 0, "stabil": 10, "stabl": 10, "standard": [0, 6, 10, 11], "start": [0, 10], "state": [6, 11], "static": [4, 6], "static_codegen": 4, "std": [0, 6], "stdin": 10, "stdunit": [3, 6], "stegun": 10, "step": 10, "still": 10, "stop": 10, "store": 10, "str": [6, 9], "strict": 6, "stride": 10, "string": 6, "strip": 0, "studi": 10, "style": 10, "sub": 10, "subclass": 10, "submodul": 2, "subok": 10, "subpackag": [0, 2], "subplot": 10, "substanc": 6, "subtract": 0, "subtyp": 10, "suggest": 10, "sum": [0, 6, 10], "sum_along_diagon": 10, "summand_1": 6, "summand_2": 6, "summat": 10, "superior": 10, "support": [0, 10, 11], "swapax": 10, "switch": 9, "symbol": [5, 6, 11], "sympi": 9, "syntax": 11, "system": 11, "t": [6, 10, 11], "tabl": 10, "take": [0, 6, 10], "taken": [0, 10], "tan": [0, 3, 10], "tangent": 10, "tanh": [0, 3, 10], "tau": 11, "tell": 6, "temperatur": [1, 6], "templat": 4, "tensordot": 10, "tera": 6, "term": 10, "test": [3, 6], "test_addition_subtract": [8, 9], "test_all_units_list": [8, 9], "test_arange_linspac": [8, 9], "test_binary_oper": [8, 9], "test_check_unit": [8, 9], "test_const": [8, 9], "test_construct": [8, 9], "test_deepcopi": [8, 9], "test_dimension_singleton": [8, 9], "test_displai": [8, 9], "test_fail_for_dimension_mismatch": [8, 9], "test_format_quant": [8, 9], "test_get_best_unit": [8, 9], "test_get_dimens": [8, 9], "test_get_unit": [8, 9], "test_inplace_on_scalar": [8, 9], "test_inplace_oper": [8, 9], "test_list": [8, 9], "test_multiplication_divis": [8, 9], "test_numpy_functions_change_dimens": [8, 9], "test_numpy_functions_dimensionless": [8, 9], "test_numpy_functions_indic": [8, 9], "test_numpy_functions_log": [8, 9], "test_numpy_functions_same_dimens": [8, 9], "test_numpy_functions_typeerror": [8, 9], "test_pickl": [8, 9], "test_pow": [8, 9], "test_set": [8, 9], "test_slic": [8, 9], "test_special_case_numpy_funct": [8, 9], "test_str_repr": [8, 9], "test_switching_off_unit_check": [8, 9], "test_unary_oper": [8, 9], "test_unit": 8, "test_unit_discarding_funct": [8, 9], "test_units_vs_quant": [8, 9], "test_unitsafe_funct": [8, 9], "text": 10, "than": [6, 10], "thei": [0, 5, 6, 9, 10, 11], "them": [5, 6, 11], "therefor": [0, 6, 10, 11], "thi": [0, 4, 6, 7, 10, 11], "thin": 0, "thing": 6, "though": [0, 11], "three": 10, "through": 10, "throw": 0, "tight": 10, "time": [5, 6, 11], "time\u00b2": 6, "titl": 10, "tofil": 0, "togeth": [10, 11], "tolist": [0, 6], "too": 10, "tool": 4, "tostr": 0, "total": 6, "toward": 10, "trace": [0, 3, 6, 10], "traceback": [0, 6, 10, 11], "track": 6, "transform": 11, "transpos": 0, "treat": 0, "treatment": 9, "triangl": 10, "trigonometr": [0, 10], "trigonometri": 10, "trim_zero": 0, "true": [0, 6, 10], "true_divid": 0, "trunc": 0, "try": [0, 10], "tupl": 10, "turn": 6, "two": [6, 10, 11], "type": [0, 6, 10], "typeerror": [0, 6, 9], "typic": 11, "u": [6, 7, 11], "ua": [6, 7], "ubc": 10, "uf": 7, "ufunc": 10, "ugli": 6, "uint8": 10, "um": [6, 7], "um2": 7, "um3": 7, "unchang": [0, 10], "underli": [10, 11], "underscor": 11, "unexpect": 10, "uniniti": 10, "unit": [1, 3, 5, 6, 7, 9, 10], "unitless": [6, 9, 11], "unitregistri": 6, "units_templ": 4, "unitsaf": 9, "unitsafefunct": [0, 3], "unitsi": [0, 11], "unless": 10, "unpack": 6, "unscal": 6, "unsign": 10, "unsupport": 0, "us": [0, 1, 5, 6, 9, 10], "use_matplotlib_units_fix": 6, "user": 6, "usiemen": 6, "usiemens3": 11, "v": [0, 6, 11], "v_": 11, "vagari": 10, "valid": 6, "valu": [0, 5, 6, 9, 10, 11], "valueerror": [0, 10], "var": [0, 6], "vari": 10, "variabl": [6, 11], "varianc": 6, "variou": [6, 9, 11], "vdot": 10, "vector": [10, 11], "veri": [6, 10], "version": [0, 6, 10, 11], "vertic": 10, "via": [9, 10], "view": [0, 6, 10], "viewpoint": 0, "volt": [6, 11], "voltag": [6, 11], "wa": [6, 10, 11], "wai": [0, 6, 9, 11], "watt": 11, "we": 10, "well": [0, 11], "were": [0, 6], "what": [6, 10], "when": [0, 6, 9, 10], "where": [0, 3, 6, 10], "wherea": [], "whether": [6, 9, 10, 11], "which": [0, 6, 10, 11], "while": [6, 10, 11], "whose": [6, 10], "wibbl": 6, "width": 10, "wiki": 10, "wikipedia": 10, "wildcard": 5, "wise": [0, 10], "with_dimens": 6, "within": 10, "without": [0, 10], "won": 10, "word": 10, "work": [0, 9, 10, 11], "worri": 6, "would": [0, 6, 10], "wrap": [0, 9], "wrap_function_dimensionless": 0, "wrap_function_keep_dimens": 0, "wrapper": 0, "write": [6, 10], "wrong": [0, 6], "wsl": 6, "x": [6, 9, 10, 11], "x1": 10, "x2": 10, "xlabel": 10, "xv": 10, "xx": 10, "y": [6, 10, 11], "yet": 0, "ygram": 5, "yield": 10, "ylabel": 10, "ylim": 10, "ylumen3": 11, "ymol": 11, "yocto": [6, 11], "york": 10, "yotta": [6, 11], "you": [0, 5, 6, 10, 11], "your": [6, 10], "yv": 10, "z": [6, 10], "zcoulomb": 5, "zepto": 6, "zero": [0, 5, 6, 10, 11], "zero_celsiu": [3, 5, 11], "zeros_lik": [3, 10], "zetta": 6, "zip": 10}, "titles": ["Units", "Welcome to unitSI\u2019s documentation!", "unitSI", "unitSI package", "unitSI.allunits module", "unitSI.constants module", "unitSI.fundamentalunits module", "unitSI.stdunits module", "unitSI.tests package", "unitSI.tests.test_units module", "unitSI.unitsafefunctions module", "Physical units"], "titleterms": {"": 1, "In": 11, "The": 11, "allunit": 4, "also": [6, 10], "ar": 11, "attribut": 6, "beginn": 11, "cast": 0, "constant": [5, 11], "content": [1, 3, 8], "document": 1, "essenti": 11, "exampl": [6, 10], "follow": 11, "function": 0, "fundamentalunit": 6, "import": 11, "indic": 1, "method": [0, 6], "modul": [3, 4, 5, 6, 7, 8, 9, 10], "ndarrai": 0, "note": [6, 10], "numpi": 0, "oper": 11, "packag": [3, 8], "paramet": [6, 10], "physic": 11, "place": 11, "quantiti": 11, "rais": [6, 10], "refer": 10, "remov": 11, "return": [6, 10], "rule": 0, "see": [6, 10], "stdunit": 7, "submodul": [3, 8], "subpackag": 3, "tabl": 1, "temperatur": 11, "test": [8, 9], "test_unit": 9, "topic": 11, "ufunc": 0, "unit": [0, 11], "unitsafefunct": 10, "unitsi": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "us": 11, "warn": 10, "welcom": 1}})
\ No newline at end of file
diff --git a/docs_sphinx/_build/html/unitSI.allunits.html b/docs_sphinx/_build/html/unitSI.allunits.html
index ecb90e2..ae21d4f 100644
--- a/docs_sphinx/_build/html/unitSI.allunits.html
+++ b/docs_sphinx/_build/html/unitSI.allunits.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
@@ -57,7 +59,7 @@
 <li class="toctree-l4"><a class="reference internal" href="unitSI.unitsafefunctions.html">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.constants.html b/docs_sphinx/_build/html/unitSI.constants.html
index 039066e..a0650ce 100644
--- a/docs_sphinx/_build/html/unitSI.constants.html
+++ b/docs_sphinx/_build/html/unitSI.constants.html
@@ -47,6 +47,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
@@ -58,7 +60,7 @@
 <li class="toctree-l4"><a class="reference internal" href="unitSI.unitsafefunctions.html">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.fundamentalunits.html b/docs_sphinx/_build/html/unitSI.fundamentalunits.html
index fc24d4a..08b71b1 100644
--- a/docs_sphinx/_build/html/unitSI.fundamentalunits.html
+++ b/docs_sphinx/_build/html/unitSI.fundamentalunits.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
@@ -57,7 +59,7 @@
 <li class="toctree-l4"><a class="reference internal" href="unitSI.unitsafefunctions.html">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.html b/docs_sphinx/_build/html/unitSI.html
index 209d21b..fe8b096 100644
--- a/docs_sphinx/_build/html/unitSI.html
+++ b/docs_sphinx/_build/html/unitSI.html
@@ -47,6 +47,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="current reference internal" href="#">unitSI package</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#subpackages">Subpackages</a><ul>
@@ -61,50 +63,7 @@
 <li class="toctree-l4"><a class="reference internal" href="unitSI.unitsafefunctions.html">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="#module-unitSI">Module contents</a><ul>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.DimensionMismatchError"><code class="docutils literal notranslate"><span class="pre">DimensionMismatchError</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.Quantity"><code class="docutils literal notranslate"><span class="pre">Quantity</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.Unit"><code class="docutils literal notranslate"><span class="pre">Unit</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arange"><code class="docutils literal notranslate"><span class="pre">arange()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arccos"><code class="docutils literal notranslate"><span class="pre">arccos()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arccosh"><code class="docutils literal notranslate"><span class="pre">arccosh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arcsin"><code class="docutils literal notranslate"><span class="pre">arcsin()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arcsinh"><code class="docutils literal notranslate"><span class="pre">arcsinh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arctan"><code class="docutils literal notranslate"><span class="pre">arctan()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.arctanh"><code class="docutils literal notranslate"><span class="pre">arctanh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.check_units"><code class="docutils literal notranslate"><span class="pre">check_units()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.cos"><code class="docutils literal notranslate"><span class="pre">cos()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.cosh"><code class="docutils literal notranslate"><span class="pre">cosh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.diagonal"><code class="docutils literal notranslate"><span class="pre">diagonal()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.dot"><code class="docutils literal notranslate"><span class="pre">dot()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.exp"><code class="docutils literal notranslate"><span class="pre">exp()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.expm1"><code class="docutils literal notranslate"><span class="pre">expm1()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.exprel"><code class="docutils literal notranslate"><span class="pre">exprel()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.get_dimensions"><code class="docutils literal notranslate"><span class="pre">get_dimensions()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.get_or_create_dimension"><code class="docutils literal notranslate"><span class="pre">get_or_create_dimension()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.get_unit"><code class="docutils literal notranslate"><span class="pre">get_unit()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.have_same_dimensions"><code class="docutils literal notranslate"><span class="pre">have_same_dimensions()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.in_best_unit"><code class="docutils literal notranslate"><span class="pre">in_best_unit()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.in_unit"><code class="docutils literal notranslate"><span class="pre">in_unit()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.is_dimensionless"><code class="docutils literal notranslate"><span class="pre">is_dimensionless()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.is_scalar_type"><code class="docutils literal notranslate"><span class="pre">is_scalar_type()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.linspace"><code class="docutils literal notranslate"><span class="pre">linspace()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.log"><code class="docutils literal notranslate"><span class="pre">log()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.log10"><code class="docutils literal notranslate"><span class="pre">log10()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.log1p"><code class="docutils literal notranslate"><span class="pre">log1p()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.ones_like"><code class="docutils literal notranslate"><span class="pre">ones_like()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.ptp"><code class="docutils literal notranslate"><span class="pre">ptp()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.ravel"><code class="docutils literal notranslate"><span class="pre">ravel()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.register_new_unit"><code class="docutils literal notranslate"><span class="pre">register_new_unit()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.sin"><code class="docutils literal notranslate"><span class="pre">sin()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.sinh"><code class="docutils literal notranslate"><span class="pre">sinh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.tan"><code class="docutils literal notranslate"><span class="pre">tan()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.tanh"><code class="docutils literal notranslate"><span class="pre">tanh()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.trace"><code class="docutils literal notranslate"><span class="pre">trace()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.where"><code class="docutils literal notranslate"><span class="pre">where()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="#unitSI.zeros_like"><code class="docutils literal notranslate"><span class="pre">zeros_like()</span></code></a></li>
-</ul>
-</li>
+<li class="toctree-l3"><a class="reference internal" href="#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
@@ -219,3480 +178,8 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Link to this headi
 </ul>
 </div>
 </section>
-<section id="module-unitSI">
-<span id="module-contents"></span><h2>Module contents<a class="headerlink" href="#module-unitSI" title="Link to this heading"></a></h2>
-<p>The unit system.</p>
-<dl class="py exception">
-<dt class="sig sig-object py" id="unitSI.DimensionMismatchError">
-<em class="property"><span class="pre">exception</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">DimensionMismatchError</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">description</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">dims</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#DimensionMismatchError"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.DimensionMismatchError" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">Exception</span></code></p>
-<p>Exception class for attempted operations with inconsistent dimensions.</p>
-<p>For example, <code class="docutils literal notranslate"><span class="pre">3*mvolt</span> <span class="pre">+</span> <span class="pre">2*amp</span></code> raises this exception. The purpose of this
-class is to help catch errors based on incorrect units. The exception will
-print a representation of the dimensions of the two inconsistent objects
-that were operated on.</p>
-<section id="parameters">
-<h3>Parameters<a class="headerlink" href="#parameters" title="Link to this heading"></a></h3>
-<dl>
-<dt>description<span class="classifier"><code class="docutils literal notranslate"><span class="pre">str</span></code></span></dt><dd><p>A description of the type of operation being performed, e.g. Addition,
-Multiplication, etc.</p>
-</dd>
-<dt>dims<span class="classifier"><cite>Dimension</cite></span></dt><dd><p>The physical dimensions of the objects involved in the operation, any
-number of them is possible</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py class">
-<dt class="sig sig-object py" id="unitSI.Quantity">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">Quantity</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dim</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">copy</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">force_quantity</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">ndarray</span></code></p>
-<p>A number with an associated physical dimension. In most cases, it is not
-necessary to create a Quantity object by hand, instead use multiplication
-and division of numbers with the constant unit names <code class="docutils literal notranslate"><span class="pre">second</span></code>,
-<code class="docutils literal notranslate"><span class="pre">kilogram</span></code>, etc.</p>
-<section id="notes">
-<h3>Notes<a class="headerlink" href="#notes" title="Link to this heading"></a></h3>
-<p>The <cite>Quantity</cite> class defines arithmetic operations which check for
-consistency of dimensions and raise the DimensionMismatchError exception
-if they are inconsistent. It also defines default and other representations
-for a number for printing purposes.</p>
-<p>See the documentation on the Unit class for more details
-about the available unit names like mvolt, etc.</p>
-<p><em>Casting rules</em></p>
-<p>The rules that define the casting operations for
-Quantity object are:</p>
-<ol class="arabic simple">
-<li><p>Quantity op Quantity = Quantity
-Performs dimension checking if appropriate</p></li>
-<li><p>(Scalar or Array) op Quantity = Quantity
-Assumes that the scalar or array is dimensionless</p></li>
-</ol>
-<p>There is one exception to the above rule, the number <code class="docutils literal notranslate"><span class="pre">0</span></code> is interpreted
-as having “any dimension”.</p>
-</section>
-<section id="examples">
-<h3>Examples<a class="headerlink" href="#examples" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">I</span> <span class="o">=</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">amp</span> <span class="c1"># I is a Quantity object</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">R</span> <span class="o">=</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">ohm</span> <span class="c1"># same for R</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">I</span> <span class="o">*</span> <span class="n">R</span>
-<span class="go">6. * volt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="n">I</span> <span class="o">*</span> <span class="n">R</span><span class="p">)</span><span class="o">.</span><span class="n">in_unit</span><span class="p">(</span><span class="n">mvolt</span><span class="p">)</span>
-<span class="go">&#39;6000. mV&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="n">I</span> <span class="o">*</span> <span class="n">R</span><span class="p">)</span> <span class="o">/</span> <span class="n">mvolt</span>
-<span class="go">6000.0</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span> <span class="o">=</span> <span class="n">I</span> <span class="o">+</span> <span class="n">R</span>  
-<span class="gt">Traceback (most recent call last):</span>
-<span class="w">    </span><span class="o">...</span>
-<span class="gr">DimensionMismatchError</span>: <span class="n">Addition, dimensions were (A) (m^2 kg s^-3 A^-2)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">Is</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span> <span class="o">*</span> <span class="n">amp</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">Is</span> <span class="o">*</span> <span class="n">R</span>
-<span class="go">array([ 2.,  4.,  6.]) * volt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">asarray</span><span class="p">(</span><span class="n">Is</span> <span class="o">*</span> <span class="n">R</span><span class="p">)</span> <span class="c1"># gets rid of units</span>
-<span class="go">array([ 2.,  4.,  6.])</span>
-</pre></div>
-</div>
-</section>
-<section id="see-also">
-<h3>See also<a class="headerlink" href="#see-also" title="Link to this heading"></a></h3>
-<p>Unit</p>
-</section>
-<section id="attributes">
-<h3>Attributes<a class="headerlink" href="#attributes" title="Link to this heading"></a></h3>
-<p>dimensions
-is_dimensionless
-dim : Dimensions</p>
-<blockquote>
-<div><p>The physical dimensions of this quantity.</p>
-</div></blockquote>
-</section>
-<section id="methods">
-<h3>Methods<a class="headerlink" href="#methods" title="Link to this heading"></a></h3>
-<p>with_dimensions
-has_same_dimensions
-in_unit
-in_best_unit</p>
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.all">
-<span class="sig-name descname"><span class="pre">all</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.all" title="Link to this definition"></a></dt>
-<dd><p>Returns True if all elements evaluate to True.</p>
-<p>Refer to <cite>numpy.all</cite> for full documentation.</p>
-<section id="id1">
-<h4>See Also<a class="headerlink" href="#id1" title="Link to this heading"></a></h4>
-<p>numpy.all : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.any">
-<span class="sig-name descname"><span class="pre">any</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.any" title="Link to this definition"></a></dt>
-<dd><p>Returns True if any of the elements of <cite>a</cite> evaluate to True.</p>
-<p>Refer to <cite>numpy.any</cite> for full documentation.</p>
-<section id="id2">
-<h4>See Also<a class="headerlink" href="#id2" title="Link to this heading"></a></h4>
-<p>numpy.any : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.argmax">
-<span class="sig-name descname"><span class="pre">argmax</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.argmax" title="Link to this definition"></a></dt>
-<dd><p>Return indices of the maximum values along the given axis.</p>
-<p>Refer to <cite>numpy.argmax</cite> for full documentation.</p>
-<section id="id3">
-<h4>See Also<a class="headerlink" href="#id3" title="Link to this heading"></a></h4>
-<p>numpy.argmax : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.argmin">
-<span class="sig-name descname"><span class="pre">argmin</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.argmin" title="Link to this definition"></a></dt>
-<dd><p>Return indices of the minimum values along the given axis.</p>
-<p>Refer to <cite>numpy.argmin</cite> for detailed documentation.</p>
-<section id="id4">
-<h4>See Also<a class="headerlink" href="#id4" title="Link to this heading"></a></h4>
-<p>numpy.argmin : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.argsort">
-<span class="sig-name descname"><span class="pre">argsort</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">-1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kind</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.argsort" title="Link to this definition"></a></dt>
-<dd><p>Returns the indices that would sort this array.</p>
-<p>Refer to <cite>numpy.argsort</cite> for full documentation.</p>
-<section id="id5">
-<h4>See Also<a class="headerlink" href="#id5" title="Link to this heading"></a></h4>
-<p>numpy.argsort : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.clip">
-<span class="sig-name descname"><span class="pre">clip</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">min</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">max</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.clip"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.clip" title="Link to this definition"></a></dt>
-<dd><p>Return an array whose values are limited to <code class="docutils literal notranslate"><span class="pre">[min,</span> <span class="pre">max]</span></code>.
-One of max or min must be given.</p>
-<p>Refer to <cite>numpy.clip</cite> for full documentation.</p>
-<section id="id6">
-<h4>See Also<a class="headerlink" href="#id6" title="Link to this heading"></a></h4>
-<p>numpy.clip : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.cumprod">
-<span class="sig-name descname"><span class="pre">cumprod</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.cumprod"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.cumprod" title="Link to this definition"></a></dt>
-<dd><p>Return the cumulative product of the elements along the given axis.</p>
-<p>Refer to <cite>numpy.cumprod</cite> for full documentation.</p>
-<section id="id7">
-<h4>See Also<a class="headerlink" href="#id7" title="Link to this heading"></a></h4>
-<p>numpy.cumprod : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.cumsum">
-<span class="sig-name descname"><span class="pre">cumsum</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.cumsum" title="Link to this definition"></a></dt>
-<dd><p>Return the cumulative sum of the elements along the given axis.</p>
-<p>Refer to <cite>numpy.cumsum</cite> for full documentation.</p>
-<section id="id8">
-<h4>See Also<a class="headerlink" href="#id8" title="Link to this heading"></a></h4>
-<p>numpy.cumsum : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.diagonal">
-<span class="sig-name descname"><span class="pre">diagonal</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">offset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis1</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis2</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.diagonal" title="Link to this definition"></a></dt>
-<dd><p>Return specified diagonals. In NumPy 1.9 the returned array is a
-read-only view instead of a copy as in previous NumPy versions.  In
-a future version the read-only restriction will be removed.</p>
-<p>Refer to <code class="xref py py-func docutils literal notranslate"><span class="pre">numpy.diagonal()</span></code> for full documentation.</p>
-<section id="id9">
-<h4>See Also<a class="headerlink" href="#id9" title="Link to this heading"></a></h4>
-<p>numpy.diagonal : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Quantity.dim">
-<span class="sig-name descname"><span class="pre">dim</span></span><a class="headerlink" href="#unitSI.Quantity.dim" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py property">
-<dt class="sig sig-object py" id="unitSI.Quantity.dimensions">
-<em class="property"><span class="pre">property</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">dimensions</span></span><a class="headerlink" href="#unitSI.Quantity.dimensions" title="Link to this definition"></a></dt>
-<dd><p>The physical dimensions of this quantity.</p>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.dot">
-<span class="sig-name descname"><span class="pre">dot</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">other</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.dot"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.dot" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.fill">
-<span class="sig-name descname"><span class="pre">fill</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.fill"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.fill" title="Link to this definition"></a></dt>
-<dd><p>Fill the array with a scalar value.</p>
-<section id="id10">
-<h4>Parameters<a class="headerlink" href="#id10" title="Link to this heading"></a></h4>
-<dl class="simple">
-<dt>value<span class="classifier">scalar</span></dt><dd><p>All elements of <cite>a</cite> will be assigned this value.</p>
-</dd>
-</dl>
-</section>
-<section id="id11">
-<h4>Examples<a class="headerlink" href="#id11" title="Link to this heading"></a></h4>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([0, 0])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([1.,  1.])</span>
-</pre></div>
-</div>
-<p>Fill expects a scalar value and always behaves the same as assigning
-to a single array element.  The following is a rare example where this
-distinction is important:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">object</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([array(3), None], dtype=object)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([array(3), array(3)], dtype=object)</span>
-</pre></div>
-</div>
-<p>Where other forms of assignments will unpack the array being assigned:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([3, 3], dtype=object)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.get_best_unit">
-<span class="sig-name descname"><span class="pre">get_best_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">regs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.get_best_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.get_best_unit" title="Link to this definition"></a></dt>
-<dd><p>Return the best unit for this <cite>Quantity</cite>.</p>
-<section id="id12">
-<h4>Parameters<a class="headerlink" href="#id12" title="Link to this heading"></a></h4>
-<dl>
-<dt>regs<span class="classifier">any number of <cite>UnitRegistry</cite> objects</span></dt><dd><p>The registries that are searched for units. If none are provided, it
-will check the standard, user and additional unit registers in turn.</p>
-</dd>
-</dl>
-</section>
-<section id="returns">
-<h4>Returns<a class="headerlink" href="#returns" title="Link to this heading"></a></h4>
-<blockquote>
-<div><dl>
-<dt>u<span class="classifier"><cite>Quantity</cite> or <cite>Unit</cite></span></dt><dd><p>The best-fitting unit for the quantity <cite>x</cite>.</p>
-</dd>
-</dl>
-</div></blockquote>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.has_same_dimensions">
-<span class="sig-name descname"><span class="pre">has_same_dimensions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">other</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.has_same_dimensions"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.has_same_dimensions" title="Link to this definition"></a></dt>
-<dd><p>Return whether this object has the same dimensions as another.</p>
-<section id="id13">
-<h4>Parameters<a class="headerlink" href="#id13" title="Link to this heading"></a></h4>
-<dl>
-<dt>other<span class="classifier">{<cite>Quantity</cite>, array-like, number}</span></dt><dd><p>The object to compare the dimensions against.</p>
-</dd>
-</dl>
-</section>
-<section id="id14">
-<h4>Returns<a class="headerlink" href="#id14" title="Link to this heading"></a></h4>
-<dl>
-<dt>same<span class="classifier"><cite>bool</cite></span></dt><dd><p><code class="docutils literal notranslate"><span class="pre">True</span></code> if <cite>other</cite> has the same dimensions.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.in_best_unit">
-<span class="sig-name descname"><span class="pre">in_best_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">precision</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">python_code</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">regs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.in_best_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.in_best_unit" title="Link to this definition"></a></dt>
-<dd><p>Represent the quantity in the “best” unit.</p>
-<section id="id15">
-<h4>Parameters<a class="headerlink" href="#id15" title="Link to this heading"></a></h4>
-<dl>
-<dt>python_code<span class="classifier"><cite>bool</cite>, optional</span></dt><dd><p>If set to <code class="docutils literal notranslate"><span class="pre">False</span></code> (the default), will return a string like
-<code class="docutils literal notranslate"><span class="pre">5.0</span> <span class="pre">um^2</span></code> which is not a valid Python expression. If set to
-<code class="docutils literal notranslate"><span class="pre">True</span></code>, it will return <code class="docutils literal notranslate"><span class="pre">5.0</span> <span class="pre">*</span> <span class="pre">um</span> <span class="pre">**</span> <span class="pre">2</span></code> instead.</p>
-</dd>
-<dt>precision<span class="classifier"><cite>int</cite>, optional</span></dt><dd><p>The number of digits of precision (in the best unit, see
-Examples). If no value is given, numpy’s
-<cite>get_printoptions</cite> value is used.</p>
-</dd>
-<dt>regs<span class="classifier"><cite>UnitRegistry</cite> objects</span></dt><dd><p>The registries where to search for units. If none are given, the
-standard, user-defined and additional registries are searched in
-that order.</p>
-</dd>
-</dl>
-</section>
-<section id="id16">
-<h4>Returns<a class="headerlink" href="#id16" title="Link to this heading"></a></h4>
-<dl>
-<dt>representation<span class="classifier"><cite>str</cite></span></dt><dd><p>A string representation of this <cite>Quantity</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id17">
-<h4>Examples<a class="headerlink" href="#id17" title="Link to this heading"></a></h4>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units</span> <span class="kn">import</span> <span class="o">*</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="mf">0.00123456</span> <span class="o">*</span> <span class="n">volt</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">in_best_unit</span><span class="p">()</span>
-<span class="go">&#39;1.23456 mV&#39;</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">in_best_unit</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
-<span class="go">&#39;1.235 mV&#39;</span>
-</pre></div>
-</div>
-</section>
-<section id="id18">
-<h4>See Also<a class="headerlink" href="#id18" title="Link to this heading"></a></h4>
-<p>in_best_unit</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.in_unit">
-<span class="sig-name descname"><span class="pre">in_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">u</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">precision</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">python_code</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.in_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.in_unit" title="Link to this definition"></a></dt>
-<dd><p>Represent the quantity in a given unit. If <cite>python_code</cite> is <code class="docutils literal notranslate"><span class="pre">True</span></code>,
-this will return valid python code, i.e. a string like <code class="docutils literal notranslate"><span class="pre">5.0</span> <span class="pre">*</span> <span class="pre">um</span> <span class="pre">**</span> <span class="pre">2</span></code>
-instead of <code class="docutils literal notranslate"><span class="pre">5.0</span> <span class="pre">um^2</span></code></p>
-<section id="id19">
-<h4>Parameters<a class="headerlink" href="#id19" title="Link to this heading"></a></h4>
-<dl>
-<dt>u<span class="classifier">{<cite>Quantity</cite>, <cite>Unit</cite>}</span></dt><dd><p>The unit in which to show the quantity.</p>
-</dd>
-<dt>precision<span class="classifier"><cite>int</cite>, optional</span></dt><dd><p>The number of digits of precision (in the given unit, see Examples).
-If no value is given, numpy’s <cite>get_printoptions</cite> value is used.</p>
-</dd>
-<dt>python_code<span class="classifier"><cite>bool</cite>, optional</span></dt><dd><p>Whether to return valid python code (<code class="docutils literal notranslate"><span class="pre">True</span></code>) or a human readable
-string (<code class="docutils literal notranslate"><span class="pre">False</span></code>, the default).</p>
-</dd>
-</dl>
-</section>
-<section id="id20">
-<h4>Returns<a class="headerlink" href="#id20" title="Link to this heading"></a></h4>
-<dl>
-<dt>s<span class="classifier"><cite>str</cite></span></dt><dd><p>String representation of the object in unit <cite>u</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id21">
-<h4>Examples<a class="headerlink" href="#id21" title="Link to this heading"></a></h4>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units.stdunits</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="mf">25.123456</span> <span class="o">*</span> <span class="n">mV</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">in_unit</span><span class="p">(</span><span class="n">volt</span><span class="p">)</span>
-<span class="go">&#39;0.02512346 V&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">in_unit</span><span class="p">(</span><span class="n">volt</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-<span class="go">&#39;0.025 V&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">in_unit</span><span class="p">(</span><span class="n">mV</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-<span class="go">&#39;25.123 mV&#39;</span>
-</pre></div>
-</div>
-</section>
-<section id="id22">
-<h4>See Also<a class="headerlink" href="#id22" title="Link to this heading"></a></h4>
-<p>in_unit</p>
-</section>
-</dd></dl>
-
-<dl class="py property">
-<dt class="sig sig-object py" id="unitSI.Quantity.is_dimensionless">
-<em class="property"><span class="pre">property</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">is_dimensionless</span></span><a class="headerlink" href="#unitSI.Quantity.is_dimensionless" title="Link to this definition"></a></dt>
-<dd><p>Whether this is a dimensionless quantity.</p>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.item">
-<span class="sig-name descname"><span class="pre">item</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.item"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.item" title="Link to this definition"></a></dt>
-<dd><p>Overwritten to assure that the returned element retains its unit.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Quantity.matplotlib">
-<span class="sig-name descname"><span class="pre">matplotlib</span></span><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">&lt;module</span> <span class="pre">'matplotlib'</span> <span class="pre">from</span> <span class="pre">'/home/sorin-wsl/anaconda3/lib/python3.11/site-packages/matplotlib/__init__.py'&gt;</span></em><a class="headerlink" href="#unitSI.Quantity.matplotlib" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.max">
-<span class="sig-name descname"><span class="pre">max</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims=False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">initial=&lt;no</span> <span class="pre">value&gt;</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.max" title="Link to this definition"></a></dt>
-<dd><p>Return the maximum along a given axis.</p>
-<p>Refer to <cite>numpy.amax</cite> for full documentation.</p>
-<section id="id23">
-<h4>See Also<a class="headerlink" href="#id23" title="Link to this heading"></a></h4>
-<p>numpy.amax : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.mean">
-<span class="sig-name descname"><span class="pre">mean</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.mean" title="Link to this definition"></a></dt>
-<dd><p>Returns the average of the array elements along given axis.</p>
-<p>Refer to <cite>numpy.mean</cite> for full documentation.</p>
-<section id="id24">
-<h4>See Also<a class="headerlink" href="#id24" title="Link to this heading"></a></h4>
-<p>numpy.mean : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.min">
-<span class="sig-name descname"><span class="pre">min</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims=False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">initial=&lt;no</span> <span class="pre">value&gt;</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.min" title="Link to this definition"></a></dt>
-<dd><p>Return the minimum along a given axis.</p>
-<p>Refer to <cite>numpy.amin</cite> for full documentation.</p>
-<section id="id25">
-<h4>See Also<a class="headerlink" href="#id25" title="Link to this heading"></a></h4>
-<p>numpy.amin : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.nonzero">
-<span class="sig-name descname"><span class="pre">nonzero</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.nonzero" title="Link to this definition"></a></dt>
-<dd><p>Return the indices of the elements that are non-zero.</p>
-<p>Refer to <cite>numpy.nonzero</cite> for full documentation.</p>
-<section id="id26">
-<h4>See Also<a class="headerlink" href="#id26" title="Link to this heading"></a></h4>
-<p>numpy.nonzero : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.prod">
-<span class="sig-name descname"><span class="pre">prod</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">initial</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.prod"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.prod" title="Link to this definition"></a></dt>
-<dd><p>Return the product of the array elements over the given axis</p>
-<p>Refer to <cite>numpy.prod</cite> for full documentation.</p>
-<section id="id27">
-<h4>See Also<a class="headerlink" href="#id27" title="Link to this heading"></a></h4>
-<p>numpy.prod : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.ptp">
-<span class="sig-name descname"><span class="pre">ptp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.ptp" title="Link to this definition"></a></dt>
-<dd><p>Peak to peak (maximum - minimum) value along a given axis.</p>
-<p>Refer to <cite>numpy.ptp</cite> for full documentation.</p>
-<section id="id28">
-<h4>See Also<a class="headerlink" href="#id28" title="Link to this heading"></a></h4>
-<p>numpy.ptp : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.put">
-<span class="sig-name descname"><span class="pre">put</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">indices</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">values</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">mode</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'raise'</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.put"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.put" title="Link to this definition"></a></dt>
-<dd><p>Set <code class="docutils literal notranslate"><span class="pre">a.flat[n]</span> <span class="pre">=</span> <span class="pre">values[n]</span></code> for all <cite>n</cite> in indices.</p>
-<p>Refer to <cite>numpy.put</cite> for full documentation.</p>
-<section id="id29">
-<h4>See Also<a class="headerlink" href="#id29" title="Link to this heading"></a></h4>
-<p>numpy.put : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.ravel">
-<span class="sig-name descname"><span class="pre">ravel</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">order</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.ravel"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.ravel" title="Link to this definition"></a></dt>
-<dd><p>Return a flattened array.</p>
-<p>Refer to <cite>numpy.ravel</cite> for full documentation.</p>
-<section id="id30">
-<h4>See Also<a class="headerlink" href="#id30" title="Link to this heading"></a></h4>
-<p>numpy.ravel : equivalent function</p>
-<p>ndarray.flat : a flat iterator on the array.</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.round">
-<span class="sig-name descname"><span class="pre">round</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">decimals</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.round" title="Link to this definition"></a></dt>
-<dd><p>Return <cite>a</cite> with each element rounded to the given number of decimals.</p>
-<p>Refer to <cite>numpy.around</cite> for full documentation.</p>
-<section id="id31">
-<h4>See Also<a class="headerlink" href="#id31" title="Link to this heading"></a></h4>
-<p>numpy.around : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.searchsorted">
-<span class="sig-name descname"><span class="pre">searchsorted</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">v</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">side</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'left'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">sorter</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.searchsorted"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.searchsorted" title="Link to this definition"></a></dt>
-<dd><p>Find indices where elements of v should be inserted in a to maintain order.</p>
-<p>For full documentation, see <cite>numpy.searchsorted</cite></p>
-<section id="id32">
-<h4>See Also<a class="headerlink" href="#id32" title="Link to this heading"></a></h4>
-<p>numpy.searchsorted : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.std">
-<span class="sig-name descname"><span class="pre">std</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ddof</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.std" title="Link to this definition"></a></dt>
-<dd><p>Returns the standard deviation of the array elements along given axis.</p>
-<p>Refer to <cite>numpy.std</cite> for full documentation.</p>
-<section id="id33">
-<h4>See Also<a class="headerlink" href="#id33" title="Link to this heading"></a></h4>
-<p>numpy.std : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.sum">
-<span class="sig-name descname"><span class="pre">sum</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">initial</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.sum" title="Link to this definition"></a></dt>
-<dd><p>Return the sum of the array elements over the given axis.</p>
-<p>Refer to <cite>numpy.sum</cite> for full documentation.</p>
-<section id="id34">
-<h4>See Also<a class="headerlink" href="#id34" title="Link to this heading"></a></h4>
-<p>numpy.sum : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.tolist">
-<span class="sig-name descname"><span class="pre">tolist</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.tolist"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.tolist" title="Link to this definition"></a></dt>
-<dd><p>Convert the array into a list.</p>
-<section id="id35">
-<h4>Returns<a class="headerlink" href="#id35" title="Link to this heading"></a></h4>
-<dl>
-<dt>l<span class="classifier">list of <cite>Quantity</cite></span></dt><dd><p>A (possibly nested) list equivalent to the original array.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.trace">
-<span class="sig-name descname"><span class="pre">trace</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">offset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis1</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis2</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.trace" title="Link to this definition"></a></dt>
-<dd><p>Return the sum along diagonals of the array.</p>
-<p>Refer to <cite>numpy.trace</cite> for full documentation.</p>
-<section id="id36">
-<h4>See Also<a class="headerlink" href="#id36" title="Link to this heading"></a></h4>
-<p>numpy.trace : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Quantity.use_matplotlib_units_fix">
-<span class="sig-name descname"><span class="pre">use_matplotlib_units_fix</span></span><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">False</span></em><a class="headerlink" href="#unitSI.Quantity.use_matplotlib_units_fix" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.var">
-<span class="sig-name descname"><span class="pre">var</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ddof</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keepdims</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.Quantity.var" title="Link to this definition"></a></dt>
-<dd><p>Returns the variance of the array elements, along given axis.</p>
-<p>Refer to <cite>numpy.var</cite> for full documentation.</p>
-<section id="id37">
-<h4>See Also<a class="headerlink" href="#id37" title="Link to this heading"></a></h4>
-<p>numpy.var : equivalent function</p>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Quantity.with_dimensions">
-<em class="property"><span class="pre">static</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">with_dimensions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">keywords</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Quantity.with_dimensions"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Quantity.with_dimensions" title="Link to this definition"></a></dt>
-<dd><p>Create a <cite>Quantity</cite> object with dim.</p>
-<section id="id38">
-<h4>Parameters<a class="headerlink" href="#id38" title="Link to this heading"></a></h4>
-<dl>
-<dt>value<span class="classifier">{array_like, number}</span></dt><dd><p>The value of the dimension</p>
-</dd>
-<dt>args<span class="classifier">{<cite>Dimension</cite>, sequence of float}</span></dt><dd><p>Either a single argument (a <cite>Dimension</cite>) or a sequence of 7 values.</p>
-</dd>
-<dt>kwds</dt><dd><p>Keywords defining the dim, see <cite>Dimension</cite> for details.</p>
-</dd>
-</dl>
-</section>
-<section id="id39">
-<h4>Returns<a class="headerlink" href="#id39" title="Link to this heading"></a></h4>
-<dl>
-<dt>q<span class="classifier"><cite>Quantity</cite></span></dt><dd><p>A <cite>Quantity</cite> object with the given dim</p>
-</dd>
-</dl>
-</section>
-<section id="id40">
-<h4>Examples<a class="headerlink" href="#id40" title="Link to this heading"></a></h4>
-<p>All of these define an equivalent <cite>Quantity</cite> object:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">Quantity</span><span class="o">.</span><span class="n">with_dimensions</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">get_or_create_dimension</span><span class="p">(</span><span class="n">length</span><span class="o">=</span><span class="mi">1</span><span class="p">))</span>
-<span class="go">2. * metre</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">Quantity</span><span class="o">.</span><span class="n">with_dimensions</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">length</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">2. * metre</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="mi">2</span> <span class="o">*</span> <span class="n">metre</span>
-<span class="go">2. * metre</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-</section>
-</dd></dl>
-
-<dl class="py class">
-<dt class="sig sig-object py" id="unitSI.Unit">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">Unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dim</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">scale</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dispname</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">latexname</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iscompound</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">copy</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit" title="Link to this definition"></a></dt>
-<dd><p>Bases: <a class="reference internal" href="unitSI.fundamentalunits.html#unitSI.fundamentalunits.Quantity" title="unitSI.fundamentalunits.Quantity"><code class="xref py py-class docutils literal notranslate"><span class="pre">Quantity</span></code></a></p>
-<blockquote>
-<div><p>A physical unit.</p>
-<p>Normally, you do not need to worry about the implementation of
-units. They are derived from the <cite>Quantity</cite> object with
-some additional information (name and string representation).</p>
-<p>Basically, a unit is just a number with given dimensions, e.g.
-mvolt = 0.001 with the dimensions of voltage. The units module
-defines a large number of standard units, and you can also define
-your own (see below).</p>
-<p>The unit class also keeps track of various things that were used
-to define it so as to generate a nice string representation of it.
-See below.</p>
-<p>When creating scaled units, you can use the following prefixes:</p>
-<blockquote>
-<div><table class="docutils align-default">
-<thead>
-<tr class="row-odd"><th class="head"><p>Factor</p></th>
-<th class="head"><p>Name</p></th>
-<th class="head"><p>Prefix</p></th>
-</tr>
-</thead>
-<tbody>
-<tr class="row-even"><td><p>10^24</p></td>
-<td><p>yotta</p></td>
-<td><p>Y</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^21</p></td>
-<td><p>zetta</p></td>
-<td><p>Z</p></td>
-</tr>
-<tr class="row-even"><td><p>10^18</p></td>
-<td><p>exa</p></td>
-<td><p>E</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^15</p></td>
-<td><p>peta</p></td>
-<td><p>P</p></td>
-</tr>
-<tr class="row-even"><td><p>10^12</p></td>
-<td><p>tera</p></td>
-<td><p>T</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^9</p></td>
-<td><p>giga</p></td>
-<td><p>G</p></td>
-</tr>
-<tr class="row-even"><td><p>10^6</p></td>
-<td><p>mega</p></td>
-<td><p>M</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^3</p></td>
-<td><p>kilo</p></td>
-<td><p>k</p></td>
-</tr>
-<tr class="row-even"><td><p>10^2</p></td>
-<td><p>hecto</p></td>
-<td><p>h</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^1</p></td>
-<td><p>deka</p></td>
-<td><p>da</p></td>
-</tr>
-<tr class="row-even"><td><p>1</p></td>
-<td></td>
-<td></td>
-</tr>
-<tr class="row-odd"><td><p>10^-1</p></td>
-<td><p>deci</p></td>
-<td><p>d</p></td>
-</tr>
-<tr class="row-even"><td><p>10^-2</p></td>
-<td><p>centi</p></td>
-<td><p>c</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^-3</p></td>
-<td><p>milli</p></td>
-<td><p>m</p></td>
-</tr>
-<tr class="row-even"><td><p>10^-6</p></td>
-<td><p>micro</p></td>
-<td><p>u (mu in SI)</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^-9</p></td>
-<td><p>nano</p></td>
-<td><p>n</p></td>
-</tr>
-<tr class="row-even"><td><p>10^-12</p></td>
-<td><p>pico</p></td>
-<td><p>p</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^-15</p></td>
-<td><p>femto</p></td>
-<td><p>f</p></td>
-</tr>
-<tr class="row-even"><td><p>10^-18</p></td>
-<td><p>atto</p></td>
-<td><p>a</p></td>
-</tr>
-<tr class="row-odd"><td><p>10^-21</p></td>
-<td><p>zepto</p></td>
-<td><p>z</p></td>
-</tr>
-<tr class="row-even"><td><p>10^-24</p></td>
-<td><p>yocto</p></td>
-<td><p>y</p></td>
-</tr>
-</tbody>
-</table>
-</div></blockquote>
-</div></blockquote>
-<p><strong>Defining your own</strong></p>
-<blockquote>
-<div><p>It can be useful to define your own units for printing
-purposes. So for example, to define the newton metre, you
-write</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units.allunits</span> <span class="kn">import</span> <span class="n">newton</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">Nm</span> <span class="o">=</span> <span class="n">newton</span> <span class="o">*</span> <span class="n">metre</span>
-</pre></div>
-</div>
-<p>You can then do</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="p">(</span><span class="mi">1</span><span class="o">*</span><span class="n">Nm</span><span class="p">)</span><span class="o">.</span><span class="n">in_unit</span><span class="p">(</span><span class="n">Nm</span><span class="p">)</span>
-<span class="go">&#39;1. N m&#39;</span>
-</pre></div>
-</div>
-<p>New “compound units”, i.e. units that are composed of other units will be
-automatically registered and from then on used for display. For example,
-imagine you define total conductance for a membrane, and the total area of
-that membrane:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">conductance</span> <span class="o">=</span> <span class="mf">10.</span><span class="o">*</span><span class="n">nS</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">area</span> <span class="o">=</span> <span class="mi">20000</span><span class="o">*</span><span class="n">um</span><span class="o">**</span><span class="mi">2</span>
-</pre></div>
-</div>
-<p>If you now ask for the conductance density, you will get an “ugly” display
-in basic SI dimensions, as Brian does not know of a corresponding unit:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">conductance</span><span class="o">/</span><span class="n">area</span>
-<span class="go">0.5 * metre ** -4 * kilogram ** -1 * second ** 3 * amp ** 2</span>
-</pre></div>
-</div>
-<p>By using an appropriate unit once, it will be registered and from then on
-used for display when appropriate:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">usiemens</span><span class="o">/</span><span class="n">cm</span><span class="o">**</span><span class="mi">2</span>
-<span class="go">usiemens / (cmetre ** 2)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">conductance</span><span class="o">/</span><span class="n">area</span>  <span class="c1"># same as before, but now Brian knows about uS/cm^2</span>
-<span class="go">50. * usiemens / (cmetre ** 2)</span>
-</pre></div>
-</div>
-<p>Note that user-defined units cannot override the standard units (<cite>volt</cite>,
-<cite>second</cite>, etc.) that are predefined by Brian. For example, the unit
-<code class="docutils literal notranslate"><span class="pre">Nm</span></code> has the dimensions “length²·mass/time²”, and therefore the same
-dimensions as the standard unit <cite>joule</cite>. The latter will be used for display
-purposes:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="mi">3</span><span class="o">*</span><span class="n">joule</span>
-<span class="go">3. * joule</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="mi">3</span><span class="o">*</span><span class="n">Nm</span>
-<span class="go">3. * joule</span>
-</pre></div>
-</div>
-</div></blockquote>
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Unit.automatically_register_units">
-<span class="sig-name descname"><span class="pre">automatically_register_units</span></span><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">True</span></em><a class="headerlink" href="#unitSI.Unit.automatically_register_units" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Unit.create">
-<em class="property"><span class="pre">static</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">create</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dim</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dispname</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">latexname</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">scale</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit.create"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit.create" title="Link to this definition"></a></dt>
-<dd><p>Create a new named unit.</p>
-<section id="id41">
-<h3>Parameters<a class="headerlink" href="#id41" title="Link to this heading"></a></h3>
-<dl>
-<dt>dim<span class="classifier"><cite>Dimension</cite></span></dt><dd><p>The dimensions of the unit.</p>
-</dd>
-<dt>name<span class="classifier"><cite>str</cite></span></dt><dd><p>The full name of the unit, e.g. <code class="docutils literal notranslate"><span class="pre">'volt'</span></code></p>
-</dd>
-<dt>dispname<span class="classifier"><cite>str</cite></span></dt><dd><p>The display name, e.g. <code class="docutils literal notranslate"><span class="pre">'V'</span></code></p>
-</dd>
-<dt>latexname<span class="classifier">str, optional</span></dt><dd><p>The name as a LaTeX expression (math mode is assumed, do not add
-$ signs or similar), e.g. <code class="docutils literal notranslate"><span class="pre">'\omega'</span></code>. If no <cite>latexname</cite> is
-specified, <cite>dispname</cite> will be used.</p>
-</dd>
-<dt>scale<span class="classifier">int, optional</span></dt><dd><p>The scale of this unit as an exponent of 10, e.g. -3 for a unit that
-is 1/1000 of the base scale. Defaults to 0 (i.e. a base unit).</p>
-</dd>
-</dl>
-</section>
-<section id="id42">
-<h3>Returns<a class="headerlink" href="#id42" title="Link to this heading"></a></h3>
-<dl>
-<dt>u<span class="classifier"><cite>Unit</cite></span></dt><dd><p>The new unit.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Unit.create_scaled_unit">
-<em class="property"><span class="pre">static</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">create_scaled_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">baseunit</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">scalefactor</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit.create_scaled_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit.create_scaled_unit" title="Link to this definition"></a></dt>
-<dd><p>Create a scaled unit from a base unit.</p>
-<section id="id43">
-<h3>Parameters<a class="headerlink" href="#id43" title="Link to this heading"></a></h3>
-<dl>
-<dt>baseunit<span class="classifier"><cite>Unit</cite></span></dt><dd><p>The unit of which to create a scaled version, e.g. <code class="docutils literal notranslate"><span class="pre">volt</span></code>,
-<code class="docutils literal notranslate"><span class="pre">amp</span></code>.</p>
-</dd>
-<dt>scalefactor<span class="classifier"><cite>str</cite></span></dt><dd><p>The scaling factor, e.g. <code class="docutils literal notranslate"><span class="pre">&quot;m&quot;</span></code> for mvolt, mamp</p>
-</dd>
-</dl>
-</section>
-<section id="id44">
-<h3>Returns<a class="headerlink" href="#id44" title="Link to this heading"></a></h3>
-<dl>
-<dt>u<span class="classifier"><cite>Unit</cite></span></dt><dd><p>The new unit.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Unit.dim">
-<span class="sig-name descname"><span class="pre">dim</span></span><a class="headerlink" href="#unitSI.Unit.dim" title="Link to this definition"></a></dt>
-<dd><p>The Dimensions of this unit</p>
-</dd></dl>
-
-<dl class="py property">
-<dt class="sig sig-object py" id="unitSI.Unit.dispname">
-<em class="property"><span class="pre">property</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">dispname</span></span><a class="headerlink" href="#unitSI.Unit.dispname" title="Link to this definition"></a></dt>
-<dd><p>The display name of the unit</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Unit.iscompound">
-<span class="sig-name descname"><span class="pre">iscompound</span></span><a class="headerlink" href="#unitSI.Unit.iscompound" title="Link to this definition"></a></dt>
-<dd><p>Whether this unit is a combination of other units.</p>
-</dd></dl>
-
-<dl class="py property">
-<dt class="sig sig-object py" id="unitSI.Unit.latexname">
-<em class="property"><span class="pre">property</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">latexname</span></span><a class="headerlink" href="#unitSI.Unit.latexname" title="Link to this definition"></a></dt>
-<dd><p>The LaTeX name of the unit</p>
-</dd></dl>
-
-<dl class="py property">
-<dt class="sig sig-object py" id="unitSI.Unit.name">
-<em class="property"><span class="pre">property</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">name</span></span><a class="headerlink" href="#unitSI.Unit.name" title="Link to this definition"></a></dt>
-<dd><p>The name of the unit</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="unitSI.Unit.scale">
-<span class="sig-name descname"><span class="pre">scale</span></span><a class="headerlink" href="#unitSI.Unit.scale" title="Link to this definition"></a></dt>
-<dd><p>The scale for this unit (as the integer exponent of 10), i.e.
-a scale of 3 means 10^3, e.g. for a “k” prefix.</p>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Unit.set_display_name">
-<span class="sig-name descname"><span class="pre">set_display_name</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit.set_display_name"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit.set_display_name" title="Link to this definition"></a></dt>
-<dd><p>Sets the display name for the unit.</p>
-<div class="deprecated">
-<p><span class="versionmodified deprecated">Deprecated since version 2.1: </span>Create a new unit with <cite>Unit.create</cite> instead.</p>
-</div>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Unit.set_latex_name">
-<span class="sig-name descname"><span class="pre">set_latex_name</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit.set_latex_name"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit.set_latex_name" title="Link to this definition"></a></dt>
-<dd><p>Sets the LaTeX name for the unit.</p>
-<div class="deprecated">
-<p><span class="versionmodified deprecated">Deprecated since version 2.1: </span>Create a new unit with <cite>Unit.create</cite> instead.</p>
-</div>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="unitSI.Unit.set_name">
-<span class="sig-name descname"><span class="pre">set_name</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#Unit.set_name"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.Unit.set_name" title="Link to this definition"></a></dt>
-<dd><p>Sets the name for the unit.</p>
-<div class="deprecated">
-<p><span class="versionmodified deprecated">Deprecated since version 2.1: </span>Create a new unit with <cite>Unit.create</cite> instead.</p>
-</div>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arange">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arange</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <span class="optional">]</span><em class="sig-param"><span class="n"><span class="pre">stop</span></span></em>, <span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">step</span></span></em>, <span class="optional">]</span><em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">like=None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/unitsafefunctions.html#arange"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.arange" title="Link to this definition"></a></dt>
-<dd><p>Return evenly spaced values within a given interval.</p>
-<p><code class="docutils literal notranslate"><span class="pre">arange</span></code> can be called with a varying number of positional arguments:</p>
-<ul class="simple">
-<li><p><code class="docutils literal notranslate"><span class="pre">arange(stop)</span></code>: Values are generated within the half-open interval
-<code class="docutils literal notranslate"><span class="pre">[0,</span> <span class="pre">stop)</span></code> (in other words, the interval including <cite>start</cite> but
-excluding <cite>stop</cite>).</p></li>
-<li><p><code class="docutils literal notranslate"><span class="pre">arange(start,</span> <span class="pre">stop)</span></code>: Values are generated within the half-open
-interval <code class="docutils literal notranslate"><span class="pre">[start,</span> <span class="pre">stop)</span></code>.</p></li>
-<li><p><code class="docutils literal notranslate"><span class="pre">arange(start,</span> <span class="pre">stop,</span> <span class="pre">step)</span></code> Values are generated within the half-open
-interval <code class="docutils literal notranslate"><span class="pre">[start,</span> <span class="pre">stop)</span></code>, with spacing between values given by
-<code class="docutils literal notranslate"><span class="pre">step</span></code>.</p></li>
-</ul>
-<p>For integer arguments the function is roughly equivalent to the Python
-built-in <code class="xref py py-class docutils literal notranslate"><span class="pre">range</span></code>, but returns an ndarray rather than a <code class="docutils literal notranslate"><span class="pre">range</span></code>
-instance.</p>
-<p>When using a non-integer step, such as 0.1, it is often better to use
-<cite>numpy.linspace</cite>.</p>
-<p>See the Warning sections below for more information.</p>
-<section id="id45">
-<h3>Parameters<a class="headerlink" href="#id45" title="Link to this heading"></a></h3>
-<dl>
-<dt>start<span class="classifier">integer or real, optional</span></dt><dd><p>Start of interval.  The interval includes this value.  The default
-start value is 0.</p>
-</dd>
-<dt>stop<span class="classifier">integer or real</span></dt><dd><p>End of interval.  The interval does not include this value, except
-in some cases where <cite>step</cite> is not an integer and floating point
-round-off affects the length of <cite>out</cite>.</p>
-</dd>
-<dt>step<span class="classifier">integer or real, optional</span></dt><dd><p>Spacing between values.  For any output <cite>out</cite>, this is the distance
-between two adjacent values, <code class="docutils literal notranslate"><span class="pre">out[i+1]</span> <span class="pre">-</span> <span class="pre">out[i]</span></code>.  The default
-step size is 1.  If <cite>step</cite> is specified as a position argument,
-<cite>start</cite> must also be given.</p>
-</dd>
-<dt>dtype<span class="classifier">dtype, optional</span></dt><dd><p>The type of the output array.  If <cite>dtype</cite> is not given, infer the data
-type from the other input arguments.</p>
-</dd>
-<dt>like<span class="classifier">array_like, optional</span></dt><dd><p>Reference object to allow the creation of arrays which are not
-NumPy arrays. If an array-like passed in as <code class="docutils literal notranslate"><span class="pre">like</span></code> supports
-the <code class="docutils literal notranslate"><span class="pre">__array_function__</span></code> protocol, the result will be defined
-by it. In this case, it ensures the creation of an array object
-compatible with that passed in via this argument.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.20.0.</span></p>
-</div>
-</dd>
-</dl>
-</section>
-<section id="id46">
-<h3>Returns<a class="headerlink" href="#id46" title="Link to this heading"></a></h3>
-<dl>
-<dt>arange<span class="classifier">ndarray</span></dt><dd><p>Array of evenly spaced values.</p>
-<p>For floating point arguments, the length of the result is
-<code class="docutils literal notranslate"><span class="pre">ceil((stop</span> <span class="pre">-</span> <span class="pre">start)/step)</span></code>.  Because of floating point overflow,
-this rule may result in the last element of <cite>out</cite> being greater
-than <cite>stop</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="warnings">
-<h3>Warnings<a class="headerlink" href="#warnings" title="Link to this heading"></a></h3>
-<p>The length of the output might not be numerically stable.</p>
-<p>Another stability issue is due to the internal implementation of
-<cite>numpy.arange</cite>.
-The actual step value used to populate the array is
-<code class="docutils literal notranslate"><span class="pre">dtype(start</span> <span class="pre">+</span> <span class="pre">step)</span> <span class="pre">-</span> <span class="pre">dtype(start)</span></code> and not <cite>step</cite>. Precision loss
-can occur here, due to casting or due to using floating points when
-<cite>start</cite> is much larger than <cite>step</cite>. This can lead to unexpected
-behaviour. For example:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">int</span><span class="p">)</span>
-<span class="go">array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">int</span><span class="p">)</span>
-<span class="go">array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])</span>
-</pre></div>
-</div>
-<p>In such cases, the use of <cite>numpy.linspace</cite> should be preferred.</p>
-<p>The built-in <code class="xref py py-class docutils literal notranslate"><span class="pre">range</span></code> generates <span class="xref std std-doc">Python built-in integers
-that have arbitrary size</span>, while <cite>numpy.arange</cite>
-produces <cite>numpy.int32</cite> or <cite>numpy.int64</cite> numbers. This may result in
-incorrect results for large integer values:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">power</span> <span class="o">=</span> <span class="mi">40</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">modulo</span> <span class="o">=</span> <span class="mi">10000</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x1</span> <span class="o">=</span> <span class="p">[(</span><span class="n">n</span> <span class="o">**</span> <span class="n">power</span><span class="p">)</span> <span class="o">%</span> <span class="n">modulo</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">8</span><span class="p">)]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x2</span> <span class="o">=</span> <span class="p">[(</span><span class="n">n</span> <span class="o">**</span> <span class="n">power</span><span class="p">)</span> <span class="o">%</span> <span class="n">modulo</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">)]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">x1</span><span class="p">)</span>
-<span class="go">[0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">x2</span><span class="p">)</span>
-<span class="go">[0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect</span>
-</pre></div>
-</div>
-</section>
-<section id="id47">
-<h3>See Also<a class="headerlink" href="#id47" title="Link to this heading"></a></h3>
-<p>numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
-numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
-numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
-<span class="xref std std-ref">how-to-partition</span></p>
-</section>
-<section id="id48">
-<h3>Examples<a class="headerlink" href="#id48" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
-<span class="go">array([0, 1, 2])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">3.0</span><span class="p">)</span>
-<span class="go">array([ 0.,  1.,  2.])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">7</span><span class="p">)</span>
-<span class="go">array([3, 4, 5, 6])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
-<span class="go">array([3, 5])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arccos">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arccos</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arccos" title="Link to this definition"></a></dt>
-<dd><p>Trigonometric inverse cosine, element-wise.</p>
-<p>The inverse of <cite>cos</cite> so that, if <code class="docutils literal notranslate"><span class="pre">y</span> <span class="pre">=</span> <span class="pre">cos(x)</span></code>, then <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">arccos(y)</span></code>.</p>
-<section id="id49">
-<h3>Parameters<a class="headerlink" href="#id49" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p><cite>x</cite>-coordinate on the unit circle.
-For real arguments, the domain is [-1, 1].</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id50"><span class="problematic" id="id51">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id52">
-<h3>Returns<a class="headerlink" href="#id52" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>angle<span class="classifier">ndarray</span></dt><dd><p>The angle of the ray intersecting the unit circle at the given
-<cite>x</cite>-coordinate in radians [0, pi].
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id53">
-<h3>See Also<a class="headerlink" href="#id53" title="Link to this heading"></a></h3>
-<p>cos, arctan, arcsin, emath.arccos</p>
-</section>
-<section id="id54">
-<h3>Notes<a class="headerlink" href="#id54" title="Link to this heading"></a></h3>
-<p><cite>arccos</cite> is a multivalued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that <code class="docutils literal notranslate"><span class="pre">cos(z)</span> <span class="pre">=</span> <span class="pre">x</span></code>. The convention is to return
-the angle <cite>z</cite> whose real part lies in <cite>[0, pi]</cite>.</p>
-<p>For real-valued input data types, <cite>arccos</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arccos</cite> is a complex analytic function that
-has branch cuts <code class="docutils literal notranslate"><span class="pre">[-inf,</span> <span class="pre">-1]</span></code> and <cite>[1, inf]</cite> and is continuous from
-above on the former and from below on the latter.</p>
-<p>The inverse <cite>cos</cite> is also known as <cite>acos</cite> or cos^-1.</p>
-</section>
-<section id="references">
-<h3>References<a class="headerlink" href="#references" title="Link to this heading"></a></h3>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 79.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_79.htm">https://personal.math.ubc.ca/~cbm/aands/page_79.htm</a></p>
-</section>
-<section id="id55">
-<h3>Examples<a class="headerlink" href="#id55" title="Link to this heading"></a></h3>
-<p>We expect the arccos of 1 to be 0, and of -1 to be pi:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arccos</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">])</span>
-<span class="go">array([ 0.        ,  3.14159265])</span>
-</pre></div>
-</div>
-<p>Plot arccos:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="mi">100</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">arccos</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">axis</span><span class="p">(</span><span class="s1">&#39;tight&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arccosh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arccosh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arccosh" title="Link to this definition"></a></dt>
-<dd><p>Inverse hyperbolic cosine, element-wise.</p>
-<section id="id56">
-<h3>Parameters<a class="headerlink" href="#id56" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id57"><span class="problematic" id="id58">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id59">
-<h3>Returns<a class="headerlink" href="#id59" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>arccosh<span class="classifier">ndarray</span></dt><dd><p>Array of the same shape as <cite>x</cite>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id60">
-<h3>See Also<a class="headerlink" href="#id60" title="Link to this heading"></a></h3>
-<p>cosh, arcsinh, sinh, arctanh, tanh</p>
-</section>
-<section id="id61">
-<h3>Notes<a class="headerlink" href="#id61" title="Link to this heading"></a></h3>
-<p><cite>arccosh</cite> is a multivalued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that <cite>cosh(z) = x</cite>. The convention is to return the
-<cite>z</cite> whose imaginary part lies in <code class="docutils literal notranslate"><span class="pre">[-pi,</span> <span class="pre">pi]</span></code> and the real part in
-<code class="docutils literal notranslate"><span class="pre">[0,</span> <span class="pre">inf]</span></code>.</p>
-<p>For real-valued input data types, <cite>arccosh</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity, it
-yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arccosh</cite> is a complex analytical function that
-has a branch cut <cite>[-inf, 1]</cite> and is continuous from above on it.</p>
-</section>
-<section id="id62">
-<h3>References<a class="headerlink" href="#id62" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id63" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 86.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_86.htm">https://personal.math.ubc.ca/~cbm/aands/page_86.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id64" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Inverse hyperbolic function”,
-<a class="reference external" href="https://en.wikipedia.org/wiki/Arccosh">https://en.wikipedia.org/wiki/Arccosh</a></p>
-</aside>
-</aside>
-</section>
-<section id="id65">
-<h3>Examples<a class="headerlink" href="#id65" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arccosh</span><span class="p">([</span><span class="n">np</span><span class="o">.</span><span class="n">e</span><span class="p">,</span> <span class="mf">10.0</span><span class="p">])</span>
-<span class="go">array([ 1.65745445,  2.99322285])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arccosh</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">0.0</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arcsin">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arcsin</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arcsin" title="Link to this definition"></a></dt>
-<dd><p>Inverse sine, element-wise.</p>
-<section id="id66">
-<h3>Parameters<a class="headerlink" href="#id66" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p><cite>y</cite>-coordinate on the unit circle.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id67"><span class="problematic" id="id68">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id69">
-<h3>Returns<a class="headerlink" href="#id69" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>angle<span class="classifier">ndarray</span></dt><dd><p>The inverse sine of each element in <cite>x</cite>, in radians and in the
-closed interval <code class="docutils literal notranslate"><span class="pre">[-pi/2,</span> <span class="pre">pi/2]</span></code>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id70">
-<h3>See Also<a class="headerlink" href="#id70" title="Link to this heading"></a></h3>
-<p>sin, cos, arccos, tan, arctan, arctan2, emath.arcsin</p>
-</section>
-<section id="id71">
-<h3>Notes<a class="headerlink" href="#id71" title="Link to this heading"></a></h3>
-<p><cite>arcsin</cite> is a multivalued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that <span class="math notranslate nohighlight">\(sin(z) = x\)</span>.  The convention is to
-return the angle <cite>z</cite> whose real part lies in [-pi/2, pi/2].</p>
-<p>For real-valued input data types, <em>arcsin</em> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arcsin</cite> is a complex analytic function that
-has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
-continuous from above on the former and from below on the latter.</p>
-<p>The inverse sine is also known as <cite>asin</cite> or sin^{-1}.</p>
-</section>
-<section id="id72">
-<h3>References<a class="headerlink" href="#id72" title="Link to this heading"></a></h3>
-<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>,
-10th printing, New York: Dover, 1964, pp. 79ff.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_79.htm">https://personal.math.ubc.ca/~cbm/aands/page_79.htm</a></p>
-</section>
-<section id="id73">
-<h3>Examples<a class="headerlink" href="#id73" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arcsin</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>     <span class="c1"># pi/2</span>
-<span class="go">1.5707963267948966</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arcsin</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>    <span class="c1"># -pi/2</span>
-<span class="go">-1.5707963267948966</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arcsin</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="go">0.0</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arcsinh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arcsinh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arcsinh" title="Link to this definition"></a></dt>
-<dd><p>Inverse hyperbolic sine element-wise.</p>
-<section id="id74">
-<h3>Parameters<a class="headerlink" href="#id74" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id75"><span class="problematic" id="id76">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id77">
-<h3>Returns<a class="headerlink" href="#id77" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Array of the same shape as <cite>x</cite>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id78">
-<h3>Notes<a class="headerlink" href="#id78" title="Link to this heading"></a></h3>
-<p><cite>arcsinh</cite> is a multivalued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that <cite>sinh(z) = x</cite>. The convention is to return the
-<cite>z</cite> whose imaginary part lies in <cite>[-pi/2, pi/2]</cite>.</p>
-<p>For real-valued input data types, <cite>arcsinh</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity, it
-returns <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arccos</cite> is a complex analytical function that
-has branch cuts <cite>[1j, infj]</cite> and <cite>[-1j, -infj]</cite> and is continuous from
-the right on the former and from the left on the latter.</p>
-<p>The inverse hyperbolic sine is also known as <cite>asinh</cite> or <code class="docutils literal notranslate"><span class="pre">sinh^-1</span></code>.</p>
-</section>
-<section id="id79">
-<h3>References<a class="headerlink" href="#id79" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id80" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 86.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_86.htm">https://personal.math.ubc.ca/~cbm/aands/page_86.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id81" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Inverse hyperbolic function”,
-<a class="reference external" href="https://en.wikipedia.org/wiki/Arcsinh">https://en.wikipedia.org/wiki/Arcsinh</a></p>
-</aside>
-</aside>
-</section>
-<section id="id82">
-<h3>Examples<a class="headerlink" href="#id82" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arcsinh</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="n">np</span><span class="o">.</span><span class="n">e</span><span class="p">,</span> <span class="mf">10.0</span><span class="p">]))</span>
-<span class="go">array([ 1.72538256,  2.99822295])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arctan">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arctan</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arctan" title="Link to this definition"></a></dt>
-<dd><p>Trigonometric inverse tangent, element-wise.</p>
-<p>The inverse of tan, so that if <code class="docutils literal notranslate"><span class="pre">y</span> <span class="pre">=</span> <span class="pre">tan(x)</span></code> then <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">arctan(y)</span></code>.</p>
-<section id="id83">
-<h3>Parameters<a class="headerlink" href="#id83" title="Link to this heading"></a></h3>
-<p>x : array_like
-out : ndarray, None, or tuple of ndarray and None, optional</p>
-<blockquote>
-<div><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</div></blockquote>
-<dl class="simple">
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id84"><span class="problematic" id="id85">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id86">
-<h3>Returns<a class="headerlink" href="#id86" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Out has the same shape as <cite>x</cite>.  Its real part is in
-<code class="docutils literal notranslate"><span class="pre">[-pi/2,</span> <span class="pre">pi/2]</span></code> (<code class="docutils literal notranslate"><span class="pre">arctan(+/-inf)</span></code> returns <code class="docutils literal notranslate"><span class="pre">+/-pi/2</span></code>).
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id87">
-<h3>See Also<a class="headerlink" href="#id87" title="Link to this heading"></a></h3>
-<dl>
-<dt>arctan2<span class="classifier">The “four quadrant” arctan of the angle formed by (<cite>x</cite>, <cite>y</cite>)</span></dt><dd><p>and the positive <cite>x</cite>-axis.</p>
-</dd>
-</dl>
-<p>angle : Argument of complex values.</p>
-</section>
-<section id="id88">
-<h3>Notes<a class="headerlink" href="#id88" title="Link to this heading"></a></h3>
-<p><cite>arctan</cite> is a multi-valued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that tan(<cite>z</cite>) = <cite>x</cite>.  The convention is to return
-the angle <cite>z</cite> whose real part lies in [-pi/2, pi/2].</p>
-<p>For real-valued input data types, <cite>arctan</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arctan</cite> is a complex analytic function that
-has [<code class="docutils literal notranslate"><span class="pre">1j,</span> <span class="pre">infj</span></code>] and [<code class="docutils literal notranslate"><span class="pre">-1j,</span> <span class="pre">-infj</span></code>] as branch cuts, and is continuous
-from the left on the former and from the right on the latter.</p>
-<p>The inverse tangent is also known as <cite>atan</cite> or tan^{-1}.</p>
-</section>
-<section id="id89">
-<h3>References<a class="headerlink" href="#id89" title="Link to this heading"></a></h3>
-<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>,
-10th printing, New York: Dover, 1964, pp. 79.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_79.htm">https://personal.math.ubc.ca/~cbm/aands/page_79.htm</a></p>
-</section>
-<section id="id90">
-<h3>Examples<a class="headerlink" href="#id90" title="Link to this heading"></a></h3>
-<p>We expect the arctan of 0 to be 0, and of 1 to be pi/4:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arctan</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
-<span class="go">array([ 0.        ,  0.78539816])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">/</span><span class="mi">4</span>
-<span class="go">0.78539816339744828</span>
-</pre></div>
-</div>
-<p>Plot arctan:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">arctan</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">axis</span><span class="p">(</span><span class="s1">&#39;tight&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.arctanh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">arctanh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.arctanh" title="Link to this definition"></a></dt>
-<dd><p>Inverse hyperbolic tangent element-wise.</p>
-<section id="id91">
-<h3>Parameters<a class="headerlink" href="#id91" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id92"><span class="problematic" id="id93">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id94">
-<h3>Returns<a class="headerlink" href="#id94" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Array of the same shape as <cite>x</cite>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id95">
-<h3>See Also<a class="headerlink" href="#id95" title="Link to this heading"></a></h3>
-<p>emath.arctanh</p>
-</section>
-<section id="id96">
-<h3>Notes<a class="headerlink" href="#id96" title="Link to this heading"></a></h3>
-<p><cite>arctanh</cite> is a multivalued function: for each <cite>x</cite> there are infinitely
-many numbers <cite>z</cite> such that <code class="docutils literal notranslate"><span class="pre">tanh(z)</span> <span class="pre">=</span> <span class="pre">x</span></code>. The convention is to return
-the <cite>z</cite> whose imaginary part lies in <cite>[-pi/2, pi/2]</cite>.</p>
-<p>For real-valued input data types, <cite>arctanh</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>arctanh</cite> is a complex analytical function
-that has branch cuts <cite>[-1, -inf]</cite> and <cite>[1, inf]</cite> and is continuous from
-above on the former and from below on the latter.</p>
-<p>The inverse hyperbolic tangent is also known as <cite>atanh</cite> or <code class="docutils literal notranslate"><span class="pre">tanh^-1</span></code>.</p>
-</section>
-<section id="id97">
-<h3>References<a class="headerlink" href="#id97" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id98" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 86.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_86.htm">https://personal.math.ubc.ca/~cbm/aands/page_86.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id99" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Inverse hyperbolic function”,
-<a class="reference external" href="https://en.wikipedia.org/wiki/Arctanh">https://en.wikipedia.org/wiki/Arctanh</a></p>
-</aside>
-</aside>
-</section>
-<section id="id100">
-<h3>Examples<a class="headerlink" href="#id100" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">arctanh</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mf">0.5</span><span class="p">])</span>
-<span class="go">array([ 0.        , -0.54930614])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.check_units">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">check_units</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">au</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#check_units"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.check_units" title="Link to this definition"></a></dt>
-<dd><p>Decorator to check units of arguments passed to a function</p>
-<section id="id101">
-<h3>Examples<a class="headerlink" href="#id101" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="nd">@check_units</span><span class="p">(</span><span class="n">I</span><span class="o">=</span><span class="n">amp</span><span class="p">,</span> <span class="n">R</span><span class="o">=</span><span class="n">ohm</span><span class="p">,</span> <span class="n">wibble</span><span class="o">=</span><span class="n">metre</span><span class="p">,</span> <span class="n">result</span><span class="o">=</span><span class="n">volt</span><span class="p">)</span>
-<span class="gp">... </span><span class="k">def</span> <span class="nf">getvoltage</span><span class="p">(</span><span class="n">I</span><span class="p">,</span> <span class="n">R</span><span class="p">,</span> <span class="o">**</span><span class="n">k</span><span class="p">):</span>
-<span class="gp">... </span>    <span class="k">return</span> <span class="n">I</span><span class="o">*</span><span class="n">R</span>
-</pre></div>
-</div>
-<p>You don’t have to check the units of every variable in the function, and
-you can define what the units should be for variables that aren’t
-explicitly named in the definition of the function. For example, the code
-above checks that the variable wibble should be a length, so writing</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">getvoltage</span><span class="p">(</span><span class="mi">1</span><span class="o">*</span><span class="n">amp</span><span class="p">,</span> <span class="mi">1</span><span class="o">*</span><span class="n">ohm</span><span class="p">,</span> <span class="n">wibble</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>  
-<span class="gt">Traceback (most recent call last):</span>
-<span class="c">...</span>
-<span class="gr">DimensionMismatchError</span>: <span class="n">Function &quot;getvoltage&quot; variable &quot;wibble&quot; has wrong dimensions, dimensions were (1) (m)</span>
-</pre></div>
-</div>
-<p>fails, but</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">getvoltage</span><span class="p">(</span><span class="mi">1</span><span class="o">*</span><span class="n">amp</span><span class="p">,</span> <span class="mi">1</span><span class="o">*</span><span class="n">ohm</span><span class="p">,</span> <span class="n">wibble</span><span class="o">=</span><span class="mi">1</span><span class="o">*</span><span class="n">metre</span><span class="p">)</span>
-<span class="go">1. * volt</span>
-</pre></div>
-</div>
-<p>passes. String arguments or <code class="docutils literal notranslate"><span class="pre">None</span></code> are not checked</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">getvoltage</span><span class="p">(</span><span class="mi">1</span><span class="o">*</span><span class="n">amp</span><span class="p">,</span> <span class="mi">1</span><span class="o">*</span><span class="n">ohm</span><span class="p">,</span> <span class="n">wibble</span><span class="o">=</span><span class="s1">&#39;hello&#39;</span><span class="p">)</span>
-<span class="go">1. * volt</span>
-</pre></div>
-</div>
-<p>By using the special name <code class="docutils literal notranslate"><span class="pre">result</span></code>, you can check the return value of the
-function.</p>
-<p>You can also use <code class="docutils literal notranslate"><span class="pre">1</span></code> or <code class="docutils literal notranslate"><span class="pre">bool</span></code> as a special value to check for a
-unitless number or a boolean value, respectively:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@check_units</span><span class="p">(</span><span class="n">value</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">absolute</span><span class="o">=</span><span class="nb">bool</span><span class="p">,</span> <span class="n">result</span><span class="o">=</span><span class="nb">bool</span><span class="p">)</span>
-<span class="gp">... </span><span class="k">def</span> <span class="nf">is_high</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">absolute</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
-<span class="gp">... </span>    <span class="k">if</span> <span class="n">absolute</span><span class="p">:</span>
-<span class="gp">... </span>        <span class="k">return</span> <span class="nb">abs</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">5</span>
-<span class="gp">... </span>    <span class="k">else</span><span class="p">:</span>
-<span class="gp">... </span>        <span class="k">return</span> <span class="n">value</span> <span class="o">&gt;=</span> <span class="mi">5</span>
-</pre></div>
-</div>
-<p>This will then again raise an error if the argument if not of the expected
-type:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">is_high</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
-<span class="go">True</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">is_high</span><span class="p">(</span><span class="o">-</span><span class="mi">7</span><span class="p">,</span> <span class="kc">True</span><span class="p">)</span>
-<span class="go">True</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">is_high</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>  
-<span class="gt">Traceback (most recent call last):</span>
-<span class="c">...</span>
-<span class="gr">TypeError</span>: <span class="n">Function &quot;is_high&quot; expected a boolean value for argument &quot;absolute&quot; but got 4.</span>
-</pre></div>
-</div>
-<p>If the return unit depends on the unit of an argument, you can also pass
-a function that takes the units of all the arguments as its inputs (in the
-order specified in the function header):</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@check_units</span><span class="p">(</span><span class="n">result</span><span class="o">=</span><span class="k">lambda</span> <span class="n">d</span><span class="p">:</span> <span class="n">d</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
-<span class="gp">... </span><span class="k">def</span> <span class="nf">square</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
-<span class="gp">... </span>    <span class="k">return</span> <span class="n">value</span><span class="o">**</span><span class="mi">2</span>
-</pre></div>
-</div>
-<p>If several arguments take arbitrary units but they have to be
-consistent among each other, you can state the name of another argument as
-a string to state that it uses the same unit as that argument.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@check_units</span><span class="p">(</span><span class="n">summand_1</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">summand_2</span><span class="o">=</span><span class="s1">&#39;summand_1&#39;</span><span class="p">)</span>
-<span class="gp">... </span><span class="k">def</span> <span class="nf">multiply_sum</span><span class="p">(</span><span class="n">multiplicand</span><span class="p">,</span> <span class="n">summand_1</span><span class="p">,</span> <span class="n">summand_2</span><span class="p">):</span>
-<span class="gp">... </span>    <span class="s2">&quot;Calculates multiplicand*(summand_1 + summand_2)&quot;</span>
-<span class="gp">... </span>    <span class="k">return</span> <span class="n">multiplicand</span><span class="o">*</span><span class="p">(</span><span class="n">summand_1</span> <span class="o">+</span> <span class="n">summand_2</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">multiply_sum</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="o">*</span><span class="n">mV</span><span class="p">,</span> <span class="mi">5</span><span class="o">*</span><span class="n">mV</span><span class="p">)</span>
-<span class="go">27. * mvolt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">multiply_sum</span><span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="n">nA</span><span class="p">,</span> <span class="mi">4</span><span class="o">*</span><span class="n">mV</span><span class="p">,</span> <span class="mi">5</span><span class="o">*</span><span class="n">mV</span><span class="p">)</span>
-<span class="go">27. * pwatt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">multiply_sum</span><span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="n">nA</span><span class="p">,</span> <span class="mi">4</span><span class="o">*</span><span class="n">mV</span><span class="p">,</span> <span class="mi">5</span><span class="o">*</span><span class="n">nA</span><span class="p">)</span>  
-<span class="gt">Traceback (most recent call last):</span>
-<span class="c">...</span>
-<span class="gr">brian2.units.fundamentalunits.DimensionMismatchError</span>: <span class="n">Function &#39;multiply_sum&#39; expected the same arguments for arguments &#39;summand_1&#39;, &#39;summand_2&#39;, but argument &#39;summand_1&#39; has unit V, while argument &#39;summand_2&#39; has unit A.</span>
-</pre></div>
-</div>
-</section>
-<section id="raises">
-<h3>Raises<a class="headerlink" href="#raises" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>DimensionMismatchError</dt><dd><p>In case the input arguments or the return value do not have the
-expected dimensions.</p>
-</dd>
-<dt>TypeError</dt><dd><p>If an input argument or return value was expected to be a boolean but
-is not.</p>
-</dd>
-</dl>
-</section>
-<section id="id102">
-<h3>Notes<a class="headerlink" href="#id102" title="Link to this heading"></a></h3>
-<p>This decorator will destroy the signature of the original function, and
-replace it with the signature <code class="docutils literal notranslate"><span class="pre">(*args,</span> <span class="pre">**kwds)</span></code>. Other decorators will
-do the same thing, and this decorator critically needs to know the signature
-of the function it is acting on, so it is important that it is the first
-decorator to act on a function. It cannot be used in combination with
-another decorator that also needs to know the signature of the function.</p>
-<p>Note that the <code class="docutils literal notranslate"><span class="pre">bool</span></code> type is “strict”, i.e. it expects a proper
-boolean value and does not accept 0 or 1. This is not the case the other
-way round, declaring an argument or return value as “1” <em>does</em> allow for a
-<code class="docutils literal notranslate"><span class="pre">True</span></code> or <code class="docutils literal notranslate"><span class="pre">False</span></code> value.</p>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.cos">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">cos</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.cos" title="Link to this definition"></a></dt>
-<dd><p>Cosine element-wise.</p>
-<section id="id103">
-<h3>Parameters<a class="headerlink" href="#id103" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array in radians.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id104"><span class="problematic" id="id105">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id106">
-<h3>Returns<a class="headerlink" href="#id106" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The corresponding cosine values.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id107">
-<h3>Notes<a class="headerlink" href="#id107" title="Link to this heading"></a></h3>
-<p>If <cite>out</cite> is provided, the function writes the result into it,
-and returns a reference to <cite>out</cite>.  (See Examples)</p>
-</section>
-<section id="id108">
-<h3>References<a class="headerlink" href="#id108" title="Link to this heading"></a></h3>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972.</p>
-</section>
-<section id="id109">
-<h3>Examples<a class="headerlink" href="#id109" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">/</span><span class="mi">2</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">]))</span>
-<span class="go">array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])</span>
-<span class="gp">&gt;&gt;&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of providing the optional output parameter</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">0</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="s1">&#39;d&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">cos</span><span class="p">([</span><span class="mf">0.1</span><span class="p">],</span> <span class="n">out1</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="ow">is</span> <span class="n">out1</span>
-<span class="go">True</span>
-<span class="gp">&gt;&gt;&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of ValueError due to provision of shape mis-matched `out`</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)),</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)))</span>
-<span class="gt">Traceback (most recent call last):</span>
-  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n">&lt;module&gt;</span>
-<span class="gr">ValueError</span>: <span class="n">operands could not be broadcast together with shapes (3,3) (2,2)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.cosh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">cosh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.cosh" title="Link to this definition"></a></dt>
-<dd><p>Hyperbolic cosine, element-wise.</p>
-<p>Equivalent to <code class="docutils literal notranslate"><span class="pre">1/2</span> <span class="pre">*</span> <span class="pre">(np.exp(x)</span> <span class="pre">+</span> <span class="pre">np.exp(-x))</span></code> and <code class="docutils literal notranslate"><span class="pre">np.cos(1j*x)</span></code>.</p>
-<section id="id110">
-<h3>Parameters<a class="headerlink" href="#id110" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id111"><span class="problematic" id="id112">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id113">
-<h3>Returns<a class="headerlink" href="#id113" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Output array of same shape as <cite>x</cite>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id114">
-<h3>Examples<a class="headerlink" href="#id114" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">cosh</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="go">1.0</span>
-</pre></div>
-</div>
-<p>The hyperbolic cosine describes the shape of a hanging cable:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">1000</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">cosh</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.diagonal">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">diagonal</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">offset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis1</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis2</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.diagonal" title="Link to this definition"></a></dt>
-<dd><p>Return specified diagonals.</p>
-<p>If <cite>a</cite> is 2-D, returns the diagonal of <cite>a</cite> with the given offset,
-i.e., the collection of elements of the form <code class="docutils literal notranslate"><span class="pre">a[i,</span> <span class="pre">i+offset]</span></code>.  If
-<cite>a</cite> has more than two dimensions, then the axes specified by <cite>axis1</cite>
-and <cite>axis2</cite> are used to determine the 2-D sub-array whose diagonal is
-returned.  The shape of the resulting array can be determined by
-removing <cite>axis1</cite> and <cite>axis2</cite> and appending an index to the right equal
-to the size of the resulting diagonals.</p>
-<p>In versions of NumPy prior to 1.7, this function always returned a new,
-independent array containing a copy of the values in the diagonal.</p>
-<p>In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
-but depending on this fact is deprecated. Writing to the resulting
-array continues to work as it used to, but a FutureWarning is issued.</p>
-<p>Starting in NumPy 1.9 it returns a read-only view on the original array.
-Attempting to write to the resulting array will produce an error.</p>
-<p>In some future release, it will return a read/write view and writing to
-the returned array will alter your original array.  The returned array
-will have the same type as the input array.</p>
-<p>If you don’t write to the array returned by this function, then you can
-just ignore all of the above.</p>
-<p>If you depend on the current behavior, then we suggest copying the
-returned array explicitly, i.e., use <code class="docutils literal notranslate"><span class="pre">np.diagonal(a).copy()</span></code> instead
-of just <code class="docutils literal notranslate"><span class="pre">np.diagonal(a)</span></code>. This will work with both past and future
-versions of NumPy.</p>
-<section id="id115">
-<h3>Parameters<a class="headerlink" href="#id115" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>a<span class="classifier">array_like</span></dt><dd><p>Array from which the diagonals are taken.</p>
-</dd>
-<dt>offset<span class="classifier">int, optional</span></dt><dd><p>Offset of the diagonal from the main diagonal.  Can be positive or
-negative.  Defaults to main diagonal (0).</p>
-</dd>
-<dt>axis1<span class="classifier">int, optional</span></dt><dd><p>Axis to be used as the first axis of the 2-D sub-arrays from which
-the diagonals should be taken.  Defaults to first axis (0).</p>
-</dd>
-<dt>axis2<span class="classifier">int, optional</span></dt><dd><p>Axis to be used as the second axis of the 2-D sub-arrays from
-which the diagonals should be taken. Defaults to second axis (1).</p>
-</dd>
-</dl>
-</section>
-<section id="id116">
-<h3>Returns<a class="headerlink" href="#id116" title="Link to this heading"></a></h3>
-<dl>
-<dt>array_of_diagonals<span class="classifier">ndarray</span></dt><dd><p>If <cite>a</cite> is 2-D, then a 1-D array containing the diagonal and of the
-same type as <cite>a</cite> is returned unless <cite>a</cite> is a <cite>matrix</cite>, in which case
-a 1-D array rather than a (2-D) <cite>matrix</cite> is returned in order to
-maintain backward compatibility.</p>
-<p>If <code class="docutils literal notranslate"><span class="pre">a.ndim</span> <span class="pre">&gt;</span> <span class="pre">2</span></code>, then the dimensions specified by <cite>axis1</cite> and <cite>axis2</cite>
-are removed, and a new axis inserted at the end corresponding to the
-diagonal.</p>
-</dd>
-</dl>
-</section>
-<section id="id117">
-<h3>Raises<a class="headerlink" href="#id117" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>ValueError</dt><dd><p>If the dimension of <cite>a</cite> is less than 2.</p>
-</dd>
-</dl>
-</section>
-<section id="id118">
-<h3>See Also<a class="headerlink" href="#id118" title="Link to this heading"></a></h3>
-<p>diag : MATLAB work-a-like for 1-D and 2-D arrays.
-diagflat : Create diagonal arrays.
-trace : Sum along diagonals.</p>
-</section>
-<section id="id119">
-<h3>Examples<a class="headerlink" href="#id119" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([[0, 1],</span>
-<span class="go">       [2, 3]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">diagonal</span><span class="p">()</span>
-<span class="go">array([0, 3])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">diagonal</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">array([1])</span>
-</pre></div>
-</div>
-<p>A 3-D example:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">);</span> <span class="n">a</span>
-<span class="go">array([[[0, 1],</span>
-<span class="go">        [2, 3]],</span>
-<span class="go">       [[4, 5],</span>
-<span class="go">        [6, 7]]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">diagonal</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span>  <span class="c1"># Main diagonals of two arrays created by skipping</span>
-<span class="gp">... </span>           <span class="mi">0</span><span class="p">,</span>  <span class="c1"># across the outer(left)-most axis last and</span>
-<span class="gp">... </span>           <span class="mi">1</span><span class="p">)</span>  <span class="c1"># the &quot;middle&quot; (row) axis first.</span>
-<span class="go">array([[0, 6],</span>
-<span class="go">       [1, 7]])</span>
-</pre></div>
-</div>
-<p>The sub-arrays whose main diagonals we just obtained; note that each
-corresponds to fixing the right-most (column) axis, and that the
-diagonals are “packed” in rows.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[:,:,</span><span class="mi">0</span><span class="p">]</span>  <span class="c1"># main diagonal is [0 6]</span>
-<span class="go">array([[0, 2],</span>
-<span class="go">       [4, 6]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[:,:,</span><span class="mi">1</span><span class="p">]</span>  <span class="c1"># main diagonal is [1 7]</span>
-<span class="go">array([[1, 3],</span>
-<span class="go">       [5, 7]])</span>
-</pre></div>
-</div>
-<p>The anti-diagonal can be obtained by reversing the order of elements
-using either <cite>numpy.flipud</cite> or <cite>numpy.fliplr</cite>.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">9</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([[0, 1, 2],</span>
-<span class="go">       [3, 4, 5],</span>
-<span class="go">       [6, 7, 8]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">fliplr</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="o">.</span><span class="n">diagonal</span><span class="p">()</span>  <span class="c1"># Horizontal flip</span>
-<span class="go">array([2, 4, 6])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">flipud</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="o">.</span><span class="n">diagonal</span><span class="p">()</span>  <span class="c1"># Vertical flip</span>
-<span class="go">array([6, 4, 2])</span>
-</pre></div>
-</div>
-<p>Note that the order in which the diagonal is retrieved varies depending
-on the flip function.</p>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.dot">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">dot</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.dot" title="Link to this definition"></a></dt>
-<dd><p>Dot product of two arrays. Specifically,</p>
-<ul>
-<li><p>If both <cite>a</cite> and <cite>b</cite> are 1-D arrays, it is inner product of vectors
-(without complex conjugation).</p></li>
-<li><p>If both <cite>a</cite> and <cite>b</cite> are 2-D arrays, it is matrix multiplication,
-but using <code class="xref py py-func docutils literal notranslate"><span class="pre">matmul()</span></code> or <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">&#64;</span> <span class="pre">b</span></code> is preferred.</p></li>
-<li><p>If either <cite>a</cite> or <cite>b</cite> is 0-D (scalar), it is equivalent to
-<code class="xref py py-func docutils literal notranslate"><span class="pre">multiply()</span></code> and using <code class="docutils literal notranslate"><span class="pre">numpy.multiply(a,</span> <span class="pre">b)</span></code> or <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">*</span> <span class="pre">b</span></code> is
-preferred.</p></li>
-<li><p>If <cite>a</cite> is an N-D array and <cite>b</cite> is a 1-D array, it is a sum product over
-the last axis of <cite>a</cite> and <cite>b</cite>.</p></li>
-<li><p>If <cite>a</cite> is an N-D array and <cite>b</cite> is an M-D array (where <code class="docutils literal notranslate"><span class="pre">M&gt;=2</span></code>), it is a
-sum product over the last axis of <cite>a</cite> and the second-to-last axis of
-<cite>b</cite>:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">dot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)[</span><span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">,</span><span class="n">k</span><span class="p">,</span><span class="n">m</span><span class="p">]</span> <span class="o">=</span> <span class="nb">sum</span><span class="p">(</span><span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">,:]</span> <span class="o">*</span> <span class="n">b</span><span class="p">[</span><span class="n">k</span><span class="p">,:,</span><span class="n">m</span><span class="p">])</span>
-</pre></div>
-</div>
-</li>
-</ul>
-<p>It uses an optimized BLAS library when possible (see <cite>numpy.linalg</cite>).</p>
-<section id="id120">
-<h3>Parameters<a class="headerlink" href="#id120" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>a<span class="classifier">array_like</span></dt><dd><p>First argument.</p>
-</dd>
-<dt>b<span class="classifier">array_like</span></dt><dd><p>Second argument.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, optional</span></dt><dd><p>Output argument. This must have the exact kind that would be returned
-if it was not used. In particular, it must have the right type, must be
-C-contiguous, and its dtype must be the dtype that would be returned
-for <cite>dot(a,b)</cite>. This is a performance feature. Therefore, if these
-conditions are not met, an exception is raised, instead of attempting
-to be flexible.</p>
-</dd>
-</dl>
-</section>
-<section id="id121">
-<h3>Returns<a class="headerlink" href="#id121" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>output<span class="classifier">ndarray</span></dt><dd><p>Returns the dot product of <cite>a</cite> and <cite>b</cite>.  If <cite>a</cite> and <cite>b</cite> are both
-scalars or both 1-D arrays then a scalar is returned; otherwise
-an array is returned.
-If <cite>out</cite> is given, then it is returned.</p>
-</dd>
-</dl>
-</section>
-<section id="id122">
-<h3>Raises<a class="headerlink" href="#id122" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>ValueError</dt><dd><p>If the last dimension of <cite>a</cite> is not the same size as
-the second-to-last dimension of <cite>b</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id123">
-<h3>See Also<a class="headerlink" href="#id123" title="Link to this heading"></a></h3>
-<p>vdot : Complex-conjugating dot product.
-tensordot : Sum products over arbitrary axes.
-einsum : Einstein summation convention.
-matmul : ‘&#64;’ operator as method with out parameter.
-linalg.multi_dot : Chained dot product.</p>
-</section>
-<section id="id124">
-<h3>Examples<a class="headerlink" href="#id124" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
-<span class="go">12</span>
-</pre></div>
-</div>
-<p>Neither argument is complex-conjugated:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">([</span><span class="mi">2</span><span class="n">j</span><span class="p">,</span> <span class="mi">3</span><span class="n">j</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="n">j</span><span class="p">,</span> <span class="mi">3</span><span class="n">j</span><span class="p">])</span>
-<span class="go">(-13+0j)</span>
-</pre></div>
-</div>
-<p>For 2-D arrays it is the matrix product:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">]]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
-<span class="go">array([[4, 1],</span>
-<span class="go">       [2, 2]])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="mi">4</span><span class="o">*</span><span class="mi">5</span><span class="o">*</span><span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="mi">4</span><span class="o">*</span><span class="mi">5</span><span class="o">*</span><span class="mi">6</span><span class="p">)[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">3</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)[</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">]</span>
-<span class="go">499128</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="nb">sum</span><span class="p">(</span><span class="n">a</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">,:]</span> <span class="o">*</span> <span class="n">b</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,:,</span><span class="mi">2</span><span class="p">])</span>
-<span class="go">499128</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.exp">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">exp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.exp" title="Link to this definition"></a></dt>
-<dd><p>Calculate the exponential of all elements in the input array.</p>
-<section id="id125">
-<h3>Parameters<a class="headerlink" href="#id125" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input values.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id126"><span class="problematic" id="id127">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id128">
-<h3>Returns<a class="headerlink" href="#id128" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Output array, element-wise exponential of <cite>x</cite>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id129">
-<h3>See Also<a class="headerlink" href="#id129" title="Link to this heading"></a></h3>
-<p>expm1 : Calculate <code class="docutils literal notranslate"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code> for all elements in the array.
-exp2  : Calculate <code class="docutils literal notranslate"><span class="pre">2**x</span></code> for all elements in the array.</p>
-</section>
-<section id="id130">
-<h3>Notes<a class="headerlink" href="#id130" title="Link to this heading"></a></h3>
-<p>The irrational number <code class="docutils literal notranslate"><span class="pre">e</span></code> is also known as Euler’s number.  It is
-approximately 2.718281, and is the base of the natural logarithm,
-<code class="docutils literal notranslate"><span class="pre">ln</span></code> (this means that, if <span class="math notranslate nohighlight">\(x = \ln y = \log_e y\)</span>,
-then <span class="math notranslate nohighlight">\(e^x = y\)</span>. For real input, <code class="docutils literal notranslate"><span class="pre">exp(x)</span></code> is always positive.</p>
-<p>For complex arguments, <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">a</span> <span class="pre">+</span> <span class="pre">ib</span></code>, we can write
-<span class="math notranslate nohighlight">\(e^x = e^a e^{ib}\)</span>.  The first term, <span class="math notranslate nohighlight">\(e^a\)</span>, is already
-known (it is the real argument, described above).  The second term,
-<span class="math notranslate nohighlight">\(e^{ib}\)</span>, is <span class="math notranslate nohighlight">\(\cos b + i \sin b\)</span>, a function with
-magnitude 1 and a periodic phase.</p>
-</section>
-<section id="id131">
-<h3>References<a class="headerlink" href="#id131" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id132" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Exponential function”,
-<a class="reference external" href="https://en.wikipedia.org/wiki/Exponential_function">https://en.wikipedia.org/wiki/Exponential_function</a></p>
-</aside>
-<aside class="footnote brackets" id="id133" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>M. Abramovitz and I. A. Stegun, “Handbook of Mathematical Functions
-with Formulas, Graphs, and Mathematical Tables,” Dover, 1964, p. 69,
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_69.htm">https://personal.math.ubc.ca/~cbm/aands/page_69.htm</a></p>
-</aside>
-</aside>
-</section>
-<section id="id134">
-<h3>Examples<a class="headerlink" href="#id134" title="Link to this heading"></a></h3>
-<p>Plot the magnitude and phase of <code class="docutils literal notranslate"><span class="pre">exp(x)</span></code> in the complex plane:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">xx</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span><span class="n">j</span> <span class="o">*</span> <span class="n">x</span><span class="p">[:,</span> <span class="n">np</span><span class="o">.</span><span class="n">newaxis</span><span class="p">]</span> <span class="c1"># a + ib over complex plane</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">xx</span><span class="p">)</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">subplot</span><span class="p">(</span><span class="mi">121</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">imshow</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">abs</span><span class="p">(</span><span class="n">out</span><span class="p">),</span>
-<span class="gp">... </span>           <span class="n">extent</span><span class="o">=</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">],</span> <span class="n">cmap</span><span class="o">=</span><span class="s1">&#39;gray&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">title</span><span class="p">(</span><span class="s1">&#39;Magnitude of exp(x)&#39;</span><span class="p">)</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">subplot</span><span class="p">(</span><span class="mi">122</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">imshow</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">angle</span><span class="p">(</span><span class="n">out</span><span class="p">),</span>
-<span class="gp">... </span>           <span class="n">extent</span><span class="o">=</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">2</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">],</span> <span class="n">cmap</span><span class="o">=</span><span class="s1">&#39;hsv&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">title</span><span class="p">(</span><span class="s1">&#39;Phase (angle) of exp(x)&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.expm1">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">expm1</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.expm1" title="Link to this definition"></a></dt>
-<dd><p>Calculate <code class="docutils literal notranslate"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code> for all elements in the array.</p>
-<section id="id135">
-<h3>Parameters<a class="headerlink" href="#id135" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input values.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id136"><span class="problematic" id="id137">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id138">
-<h3>Returns<a class="headerlink" href="#id138" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray or scalar</span></dt><dd><p>Element-wise exponential minus one: <code class="docutils literal notranslate"><span class="pre">out</span> <span class="pre">=</span> <span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code>.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id139">
-<h3>See Also<a class="headerlink" href="#id139" title="Link to this heading"></a></h3>
-<p>log1p : <code class="docutils literal notranslate"><span class="pre">log(1</span> <span class="pre">+</span> <span class="pre">x)</span></code>, the inverse of expm1.</p>
-</section>
-<section id="id140">
-<h3>Notes<a class="headerlink" href="#id140" title="Link to this heading"></a></h3>
-<p>This function provides greater precision than <code class="docutils literal notranslate"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code>
-for small values of <code class="docutils literal notranslate"><span class="pre">x</span></code>.</p>
-</section>
-<section id="id141">
-<h3>Examples<a class="headerlink" href="#id141" title="Link to this heading"></a></h3>
-<p>The true value of <code class="docutils literal notranslate"><span class="pre">exp(1e-10)</span> <span class="pre">-</span> <span class="pre">1</span></code> is <code class="docutils literal notranslate"><span class="pre">1.00000000005e-10</span></code> to
-about 32 significant digits. This example shows the superiority of
-expm1 in this case.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">expm1</span><span class="p">(</span><span class="mf">1e-10</span><span class="p">)</span>
-<span class="go">1.00000000005e-10</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="mf">1e-10</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
-<span class="go">1.000000082740371e-10</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.exprel">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">exprel</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.exprel" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.get_dimensions">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">get_dimensions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#get_dimensions"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.get_dimensions" title="Link to this definition"></a></dt>
-<dd><p>Return the dimensions of any object that has them.</p>
-<p>Slightly more general than <cite>Quantity.dimensions</cite> because it will
-return <cite>DIMENSIONLESS</cite> if the object is of number type but not a <cite>Quantity</cite>
-(e.g. a <cite>float</cite> or <cite>int</cite>).</p>
-<section id="id142">
-<h3>Parameters<a class="headerlink" href="#id142" title="Link to this heading"></a></h3>
-<dl>
-<dt>obj<span class="classifier"><cite>object</cite></span></dt><dd><p>The object to check.</p>
-</dd>
-</dl>
-</section>
-<section id="id143">
-<h3>Returns<a class="headerlink" href="#id143" title="Link to this heading"></a></h3>
-<dl>
-<dt>dim<span class="classifier"><cite>Dimension</cite></span></dt><dd><p>The physical dimensions of the <cite>obj</cite>.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.get_or_create_dimension">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">get_or_create_dimension</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#get_or_create_dimension"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.get_or_create_dimension" title="Link to this definition"></a></dt>
-<dd><p>Create a new Dimension object or get a reference to an existing one.
-This function takes care of only creating new objects if they were not
-created before and otherwise returning a reference to an existing object.
-This allows to compare dimensions very efficiently using <code class="docutils literal notranslate"><span class="pre">is</span></code>.</p>
-<section id="id144">
-<h3>Parameters<a class="headerlink" href="#id144" title="Link to this heading"></a></h3>
-<dl>
-<dt>args<span class="classifier">sequence of <cite>float</cite></span></dt><dd><p>A sequence with the indices of the 7 elements of an SI dimension.</p>
-</dd>
-<dt>kwds<span class="classifier">keyword arguments</span></dt><dd><p>a sequence of <code class="docutils literal notranslate"><span class="pre">keyword=value</span></code> pairs where the keywords are the names of
-the SI dimensions, or the standard unit.</p>
-</dd>
-</dl>
-</section>
-<section id="id145">
-<h3>Examples<a class="headerlink" href="#id145" title="Link to this heading"></a></h3>
-<p>The following are all definitions of the dimensions of force</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">get_or_create_dimension</span><span class="p">(</span><span class="n">length</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">mass</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">time</span><span class="o">=-</span><span class="mi">2</span><span class="p">)</span>
-<span class="go">metre * kilogram * second ** -2</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">get_or_create_dimension</span><span class="p">(</span><span class="n">m</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">kg</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">s</span><span class="o">=-</span><span class="mi">2</span><span class="p">)</span>
-<span class="go">metre * kilogram * second ** -2</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">get_or_create_dimension</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])</span>
-<span class="go">metre * kilogram * second ** -2</span>
-</pre></div>
-</div>
-</section>
-<section id="id146">
-<h3>Notes<a class="headerlink" href="#id146" title="Link to this heading"></a></h3>
-<p>The 7 units are (in order):</p>
-<p>Length, Mass, Time, Electric Current, Temperature,
-Quantity of Substance, Luminosity</p>
-<p>and can be referred to either by these names or their SI unit names,
-e.g. length, metre, and m all refer to the same thing here.</p>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.get_unit">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">get_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">d</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#get_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.get_unit" title="Link to this definition"></a></dt>
-<dd><p>Find an unscaled unit (e.g. <cite>volt</cite> but not <cite>mvolt</cite>) for a <cite>Dimension</cite>.</p>
-<section id="id147">
-<h3>Parameters<a class="headerlink" href="#id147" title="Link to this heading"></a></h3>
-<dl>
-<dt>d<span class="classifier"><cite>Dimension</cite></span></dt><dd><p>The dimension to find a unit for.</p>
-</dd>
-</dl>
-</section>
-<section id="id148">
-<h3>Returns<a class="headerlink" href="#id148" title="Link to this heading"></a></h3>
-<dl>
-<dt>u<span class="classifier"><cite>Unit</cite></span></dt><dd><p>A registered unscaled <cite>Unit</cite> for the dimensions <code class="docutils literal notranslate"><span class="pre">d</span></code>, or a new <cite>Unit</cite>
-if no unit was found.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.have_same_dimensions">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">have_same_dimensions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">obj2</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#have_same_dimensions"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.have_same_dimensions" title="Link to this definition"></a></dt>
-<dd><p>Test if two values have the same dimensions.</p>
-<section id="id149">
-<h3>Parameters<a class="headerlink" href="#id149" title="Link to this heading"></a></h3>
-<dl>
-<dt>obj1, obj2<span class="classifier">{<cite>Quantity</cite>, array-like, number}</span></dt><dd><p>The values of which to compare the dimensions.</p>
-</dd>
-</dl>
-</section>
-<section id="id150">
-<h3>Returns<a class="headerlink" href="#id150" title="Link to this heading"></a></h3>
-<dl>
-<dt>same<span class="classifier"><cite>bool</cite></span></dt><dd><p><code class="docutils literal notranslate"><span class="pre">True</span></code> if <cite>obj1</cite> and <cite>obj2</cite> have the same dimensions.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.in_best_unit">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">in_best_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">precision</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#in_best_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.in_best_unit" title="Link to this definition"></a></dt>
-<dd><p>Represent the value in the “best” unit.</p>
-<section id="id151">
-<h3>Parameters<a class="headerlink" href="#id151" title="Link to this heading"></a></h3>
-<dl>
-<dt>x<span class="classifier">{<cite>Quantity</cite>, array-like, number}</span></dt><dd><p>The value to display</p>
-</dd>
-<dt>precision<span class="classifier"><cite>int</cite>, optional</span></dt><dd><p>The number of digits of precision (in the best unit, see Examples).
-If no value is given, numpy’s <cite>get_printoptions</cite> value is used.</p>
-</dd>
-</dl>
-</section>
-<section id="id152">
-<h3>Returns<a class="headerlink" href="#id152" title="Link to this heading"></a></h3>
-<dl>
-<dt>representation<span class="classifier"><cite>str</cite></span></dt><dd><p>A string representation of this <cite>Quantity</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id153">
-<h3>Examples<a class="headerlink" href="#id153" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2.units</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_best_unit</span><span class="p">(</span><span class="mf">0.00123456</span> <span class="o">*</span> <span class="n">volt</span><span class="p">)</span>
-<span class="go">&#39;1.23456 mV&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_best_unit</span><span class="p">(</span><span class="mf">0.00123456</span> <span class="o">*</span> <span class="n">volt</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
-<span class="go">&#39;1.23 mV&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_best_unit</span><span class="p">(</span><span class="mf">0.123456</span><span class="p">)</span>
-<span class="go">&#39;0.123456&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_best_unit</span><span class="p">(</span><span class="mf">0.123456</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
-<span class="go">&#39;0.12&#39;</span>
-</pre></div>
-</div>
-</section>
-<section id="id154">
-<h3>See Also<a class="headerlink" href="#id154" title="Link to this heading"></a></h3>
-<p>Quantity.in_best_unit</p>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.in_unit">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">in_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">u</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">precision</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#in_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.in_unit" title="Link to this definition"></a></dt>
-<dd><p>Display a value in a certain unit with a given precision.</p>
-<section id="id155">
-<h3>Parameters<a class="headerlink" href="#id155" title="Link to this heading"></a></h3>
-<dl>
-<dt>x<span class="classifier">{<cite>Quantity</cite>, array-like, number}</span></dt><dd><p>The value to display</p>
-</dd>
-<dt>u<span class="classifier">{<cite>Quantity</cite>, <cite>Unit</cite>}</span></dt><dd><p>The unit to display the value <cite>x</cite> in.</p>
-</dd>
-<dt>precision<span class="classifier"><cite>int</cite>, optional</span></dt><dd><p>The number of digits of precision (in the given unit, see Examples).
-If no value is given, numpy’s <cite>get_printoptions</cite> value is used.</p>
-</dd>
-</dl>
-</section>
-<section id="id156">
-<h3>Returns<a class="headerlink" href="#id156" title="Link to this heading"></a></h3>
-<dl>
-<dt>s<span class="classifier"><cite>str</cite></span></dt><dd><p>A string representation of <cite>x</cite> in units of <cite>u</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id157">
-<h3>Examples<a class="headerlink" href="#id157" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_unit</span><span class="p">(</span><span class="mi">3</span> <span class="o">*</span> <span class="n">volt</span><span class="p">,</span> <span class="n">mvolt</span><span class="p">)</span>
-<span class="go">&#39;3000. mV&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_unit</span><span class="p">(</span><span class="mi">123123</span> <span class="o">*</span> <span class="n">msecond</span><span class="p">,</span> <span class="n">second</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
-<span class="go">&#39;123.12 s&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_unit</span><span class="p">(</span><span class="mi">10</span> <span class="o">*</span> <span class="n">uA</span><span class="o">/</span><span class="n">cm</span><span class="o">**</span><span class="mi">2</span><span class="p">,</span> <span class="n">nA</span><span class="o">/</span><span class="n">um</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
-<span class="go">&#39;1.00000000e-04 nA/(um^2)&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_unit</span><span class="p">(</span><span class="mi">10</span> <span class="o">*</span> <span class="n">mV</span><span class="p">,</span> <span class="n">ohm</span> <span class="o">*</span> <span class="n">amp</span><span class="p">)</span>
-<span class="go">&#39;0.01 ohm A&#39;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">in_unit</span><span class="p">(</span><span class="mi">10</span> <span class="o">*</span> <span class="n">nS</span><span class="p">,</span> <span class="n">ohm</span><span class="p">)</span> 
-<span class="gp">... </span>                      
-<span class="gt">Traceback (most recent call last):</span>
-<span class="w">    </span><span class="o">...</span>
-<span class="gr">DimensionMismatchError</span>: <span class="n">Non-matching unit for method &quot;in_unit&quot;,</span>
-<span class="x">dimensions were (m^-2 kg^-1 s^3 A^2) (m^2 kg s^-3 A^-2)</span>
-</pre></div>
-</div>
-</section>
-<section id="id158">
-<h3>See Also<a class="headerlink" href="#id158" title="Link to this heading"></a></h3>
-<p>Quantity.in_unit</p>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.is_dimensionless">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">is_dimensionless</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#is_dimensionless"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.is_dimensionless" title="Link to this definition"></a></dt>
-<dd><p>Test if a value is dimensionless or not.</p>
-<section id="id159">
-<h3>Parameters<a class="headerlink" href="#id159" title="Link to this heading"></a></h3>
-<dl>
-<dt>obj<span class="classifier"><cite>object</cite></span></dt><dd><p>The object to check.</p>
-</dd>
-</dl>
-</section>
-<section id="id160">
-<h3>Returns<a class="headerlink" href="#id160" title="Link to this heading"></a></h3>
-<dl>
-<dt>dimensionless<span class="classifier"><cite>bool</cite></span></dt><dd><p><code class="docutils literal notranslate"><span class="pre">True</span></code> if <cite>obj</cite> is dimensionless.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.is_scalar_type">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">is_scalar_type</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#is_scalar_type"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.is_scalar_type" title="Link to this definition"></a></dt>
-<dd><p>Tells you if the object is a 1d number type.</p>
-<section id="id161">
-<h3>Parameters<a class="headerlink" href="#id161" title="Link to this heading"></a></h3>
-<dl>
-<dt>obj<span class="classifier"><cite>object</cite></span></dt><dd><p>The object to check.</p>
-</dd>
-</dl>
-</section>
-<section id="id162">
-<h3>Returns<a class="headerlink" href="#id162" title="Link to this heading"></a></h3>
-<dl>
-<dt>scalar<span class="classifier"><cite>bool</cite></span></dt><dd><p><code class="docutils literal notranslate"><span class="pre">True</span></code> if <cite>obj</cite> is a scalar that can be interpreted as a
-dimensionless <cite>Quantity</cite>.</p>
-</dd>
-</dl>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.linspace">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">linspace</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">stop</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">num</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">50</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">endpoint</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">retstep</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/unitsafefunctions.html#linspace"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.linspace" title="Link to this definition"></a></dt>
-<dd><p>Return evenly spaced numbers over a specified interval.</p>
-<p>Returns <cite>num</cite> evenly spaced samples, calculated over the
-interval [<cite>start</cite>, <cite>stop</cite>].</p>
-<p>The endpoint of the interval can optionally be excluded.</p>
-<div class="versionchanged">
-<p><span class="versionmodified changed">Changed in version 1.16.0: </span>Non-scalar <cite>start</cite> and <cite>stop</cite> are now supported.</p>
-</div>
-<div class="versionchanged">
-<p><span class="versionmodified changed">Changed in version 1.20.0: </span>Values are rounded towards <code class="docutils literal notranslate"><span class="pre">-inf</span></code> instead of <code class="docutils literal notranslate"><span class="pre">0</span></code> when an
-integer <code class="docutils literal notranslate"><span class="pre">dtype</span></code> is specified. The old behavior can
-still be obtained with <code class="docutils literal notranslate"><span class="pre">np.linspace(start,</span> <span class="pre">stop,</span> <span class="pre">num).astype(int)</span></code></p>
-</div>
-<section id="id163">
-<h3>Parameters<a class="headerlink" href="#id163" title="Link to this heading"></a></h3>
-<dl>
-<dt>start<span class="classifier">array_like</span></dt><dd><p>The starting value of the sequence.</p>
-</dd>
-<dt>stop<span class="classifier">array_like</span></dt><dd><p>The end value of the sequence, unless <cite>endpoint</cite> is set to False.
-In that case, the sequence consists of all but the last of <code class="docutils literal notranslate"><span class="pre">num</span> <span class="pre">+</span> <span class="pre">1</span></code>
-evenly spaced samples, so that <cite>stop</cite> is excluded.  Note that the step
-size changes when <cite>endpoint</cite> is False.</p>
-</dd>
-<dt>num<span class="classifier">int, optional</span></dt><dd><p>Number of samples to generate. Default is 50. Must be non-negative.</p>
-</dd>
-<dt>endpoint<span class="classifier">bool, optional</span></dt><dd><p>If True, <cite>stop</cite> is the last sample. Otherwise, it is not included.
-Default is True.</p>
-</dd>
-<dt>retstep<span class="classifier">bool, optional</span></dt><dd><p>If True, return (<cite>samples</cite>, <cite>step</cite>), where <cite>step</cite> is the spacing
-between samples.</p>
-</dd>
-<dt>dtype<span class="classifier">dtype, optional</span></dt><dd><p>The type of the output array.  If <cite>dtype</cite> is not given, the data type
-is inferred from <cite>start</cite> and <cite>stop</cite>. The inferred dtype will never be
-an integer; <cite>float</cite> is chosen even if the arguments would produce an
-array of integers.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.9.0.</span></p>
-</div>
-</dd>
-<dt>axis<span class="classifier">int, optional</span></dt><dd><p>The axis in the result to store the samples.  Relevant only if start
-or stop are array-like.  By default (0), the samples will be along a
-new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.16.0.</span></p>
-</div>
-</dd>
-</dl>
-</section>
-<section id="id164">
-<h3>Returns<a class="headerlink" href="#id164" title="Link to this heading"></a></h3>
-<dl>
-<dt>samples<span class="classifier">ndarray</span></dt><dd><p>There are <cite>num</cite> equally spaced samples in the closed interval
-<code class="docutils literal notranslate"><span class="pre">[start,</span> <span class="pre">stop]</span></code> or the half-open interval <code class="docutils literal notranslate"><span class="pre">[start,</span> <span class="pre">stop)</span></code>
-(depending on whether <cite>endpoint</cite> is True or False).</p>
-</dd>
-<dt>step<span class="classifier">float, optional</span></dt><dd><p>Only returned if <cite>retstep</cite> is True</p>
-<p>Size of spacing between samples.</p>
-</dd>
-</dl>
-</section>
-<section id="id165">
-<h3>See Also<a class="headerlink" href="#id165" title="Link to this heading"></a></h3>
-<dl>
-<dt>arange<span class="classifier">Similar to <cite>linspace</cite>, but uses a step size (instead of the</span></dt><dd><p>number of samples).</p>
-</dd>
-<dt>geomspace<span class="classifier">Similar to <cite>linspace</cite>, but with numbers spaced evenly on a log</span></dt><dd><p>scale (a geometric progression).</p>
-</dd>
-<dt>logspace<span class="classifier">Similar to <cite>geomspace</cite>, but with the end points specified as</span></dt><dd><p>logarithms.</p>
-</dd>
-</dl>
-<p><span class="xref std std-ref">how-to-partition</span></p>
-</section>
-<section id="id166">
-<h3>Examples<a class="headerlink" href="#id166" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
-<span class="go">array([2.  , 2.25, 2.5 , 2.75, 3.  ])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">endpoint</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
-<span class="go">array([2. ,  2.2,  2.4,  2.6,  2.8])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">retstep</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
-<span class="go">(array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)</span>
-</pre></div>
-</div>
-<p>Graphical illustration:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">N</span> <span class="o">=</span> <span class="mi">8</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="n">N</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">endpoint</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">endpoint</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x1</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;o&#39;</span><span class="p">)</span>
-<span class="go">[&lt;matplotlib.lines.Line2D object at 0x...&gt;]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x2</span><span class="p">,</span> <span class="n">y</span> <span class="o">+</span> <span class="mf">0.5</span><span class="p">,</span> <span class="s1">&#39;o&#39;</span><span class="p">)</span>
-<span class="go">[&lt;matplotlib.lines.Line2D object at 0x...&gt;]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">ylim</span><span class="p">([</span><span class="o">-</span><span class="mf">0.5</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
-<span class="go">(-0.5, 1)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.log">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">log</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.log" title="Link to this definition"></a></dt>
-<dd><p>Natural logarithm, element-wise.</p>
-<p>The natural logarithm <cite>log</cite> is the inverse of the exponential function,
-so that <cite>log(exp(x)) = x</cite>. The natural logarithm is logarithm in base
-<cite>e</cite>.</p>
-<section id="id167">
-<h3>Parameters<a class="headerlink" href="#id167" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input value.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id168"><span class="problematic" id="id169">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id170">
-<h3>Returns<a class="headerlink" href="#id170" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The natural logarithm of <cite>x</cite>, element-wise.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id171">
-<h3>See Also<a class="headerlink" href="#id171" title="Link to this heading"></a></h3>
-<p>log10, log2, log1p, emath.log</p>
-</section>
-<section id="id172">
-<h3>Notes<a class="headerlink" href="#id172" title="Link to this heading"></a></h3>
-<p>Logarithm is a multivalued function: for each <cite>x</cite> there is an infinite
-number of <cite>z</cite> such that <cite>exp(z) = x</cite>. The convention is to return the
-<cite>z</cite> whose imaginary part lies in <cite>(-pi, pi]</cite>.</p>
-<p>For real-valued input data types, <cite>log</cite> always returns real output. For
-each value that cannot be expressed as a real number or infinity, it
-yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>log</cite> is a complex analytical function that
-has a branch cut <cite>[-inf, 0]</cite> and is continuous from above on it. <cite>log</cite>
-handles the floating-point negative zero as an infinitesimal negative
-number, conforming to the C99 standard.</p>
-<p>In the cases where the input has a negative real part and a very small
-negative complex part (approaching 0), the result is so close to <cite>-pi</cite>
-that it evaluates to exactly <cite>-pi</cite>.</p>
-</section>
-<section id="id173">
-<h3>References<a class="headerlink" href="#id173" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id174" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 67.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_67.htm">https://personal.math.ubc.ca/~cbm/aands/page_67.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id175" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Logarithm”. <a class="reference external" href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-</aside>
-</aside>
-</section>
-<section id="id176">
-<h3>Examples<a class="headerlink" href="#id176" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">log</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">e</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">e</span><span class="o">**</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">])</span>
-<span class="go">array([  0.,   1.,   2., -Inf])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.log10">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">log10</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.log10" title="Link to this definition"></a></dt>
-<dd><p>Return the base 10 logarithm of the input array, element-wise.</p>
-<section id="id177">
-<h3>Parameters<a class="headerlink" href="#id177" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input values.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id178"><span class="problematic" id="id179">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id180">
-<h3>Returns<a class="headerlink" href="#id180" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The logarithm to the base 10 of <cite>x</cite>, element-wise. NaNs are
-returned where x is negative.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id181">
-<h3>See Also<a class="headerlink" href="#id181" title="Link to this heading"></a></h3>
-<p>emath.log10</p>
-</section>
-<section id="id182">
-<h3>Notes<a class="headerlink" href="#id182" title="Link to this heading"></a></h3>
-<p>Logarithm is a multivalued function: for each <cite>x</cite> there is an infinite
-number of <cite>z</cite> such that <cite>10**z = x</cite>. The convention is to return the
-<cite>z</cite> whose imaginary part lies in <cite>(-pi, pi]</cite>.</p>
-<p>For real-valued input data types, <cite>log10</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>log10</cite> is a complex analytical function that
-has a branch cut <cite>[-inf, 0]</cite> and is continuous from above on it.
-<cite>log10</cite> handles the floating-point negative zero as an infinitesimal
-negative number, conforming to the C99 standard.</p>
-<p>In the cases where the input has a negative real part and a very small
-negative complex part (approaching 0), the result is so close to <cite>-pi</cite>
-that it evaluates to exactly <cite>-pi</cite>.</p>
-</section>
-<section id="id183">
-<h3>References<a class="headerlink" href="#id183" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id184" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 67.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_67.htm">https://personal.math.ubc.ca/~cbm/aands/page_67.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id185" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Logarithm”. <a class="reference external" href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-</aside>
-</aside>
-</section>
-<section id="id186">
-<h3>Examples<a class="headerlink" href="#id186" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">log10</span><span class="p">([</span><span class="mf">1e-15</span><span class="p">,</span> <span class="o">-</span><span class="mf">3.</span><span class="p">])</span>
-<span class="go">array([-15.,  nan])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.log1p">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">log1p</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.log1p" title="Link to this definition"></a></dt>
-<dd><p>Return the natural logarithm of one plus the input array, element-wise.</p>
-<p>Calculates <code class="docutils literal notranslate"><span class="pre">log(1</span> <span class="pre">+</span> <span class="pre">x)</span></code>.</p>
-<section id="id187">
-<h3>Parameters<a class="headerlink" href="#id187" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input values.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id188"><span class="problematic" id="id189">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id190">
-<h3>Returns<a class="headerlink" href="#id190" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>Natural logarithm of <cite>1 + x</cite>, element-wise.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id191">
-<h3>See Also<a class="headerlink" href="#id191" title="Link to this heading"></a></h3>
-<p>expm1 : <code class="docutils literal notranslate"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code>, the inverse of <cite>log1p</cite>.</p>
-</section>
-<section id="id192">
-<h3>Notes<a class="headerlink" href="#id192" title="Link to this heading"></a></h3>
-<p>For real-valued input, <cite>log1p</cite> is accurate also for <cite>x</cite> so small
-that <cite>1 + x == 1</cite> in floating-point accuracy.</p>
-<p>Logarithm is a multivalued function: for each <cite>x</cite> there is an infinite
-number of <cite>z</cite> such that <cite>exp(z) = 1 + x</cite>. The convention is to return
-the <cite>z</cite> whose imaginary part lies in <cite>[-pi, pi]</cite>.</p>
-<p>For real-valued input data types, <cite>log1p</cite> always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields <code class="docutils literal notranslate"><span class="pre">nan</span></code> and sets the <cite>invalid</cite> floating point error flag.</p>
-<p>For complex-valued input, <cite>log1p</cite> is a complex analytical function that
-has a branch cut <cite>[-inf, -1]</cite> and is continuous from above on it.
-<cite>log1p</cite> handles the floating-point negative zero as an infinitesimal
-negative number, conforming to the C99 standard.</p>
-</section>
-<section id="id193">
-<h3>References<a class="headerlink" href="#id193" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id194" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,
-10th printing, 1964, pp. 67.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_67.htm">https://personal.math.ubc.ca/~cbm/aands/page_67.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id195" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Logarithm”. <a class="reference external" href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-</aside>
-</aside>
-</section>
-<section id="id196">
-<h3>Examples<a class="headerlink" href="#id196" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">log1p</span><span class="p">(</span><span class="mf">1e-99</span><span class="p">)</span>
-<span class="go">1e-99</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="mi">1</span> <span class="o">+</span> <span class="mf">1e-99</span><span class="p">)</span>
-<span class="go">0.0</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.ones_like">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">ones_like</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.ones_like" title="Link to this definition"></a></dt>
-<dd><p>Return an array of ones with the same shape and type as a given array.</p>
-<section id="id197">
-<h3>Parameters<a class="headerlink" href="#id197" title="Link to this heading"></a></h3>
-<dl>
-<dt>a<span class="classifier">array_like</span></dt><dd><p>The shape and data-type of <cite>a</cite> define these same attributes of
-the returned array.</p>
-</dd>
-<dt>dtype<span class="classifier">data-type, optional</span></dt><dd><p>Overrides the data type of the result.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.6.0.</span></p>
-</div>
-</dd>
-<dt>order<span class="classifier">{‘C’, ‘F’, ‘A’, or ‘K’}, optional</span></dt><dd><p>Overrides the memory layout of the result. ‘C’ means C-order,
-‘F’ means F-order, ‘A’ means ‘F’ if <cite>a</cite> is Fortran contiguous,
-‘C’ otherwise. ‘K’ means match the layout of <cite>a</cite> as closely
-as possible.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.6.0.</span></p>
-</div>
-</dd>
-<dt>subok<span class="classifier">bool, optional.</span></dt><dd><p>If True, then the newly created array will use the sub-class
-type of <cite>a</cite>, otherwise it will be a base-class array. Defaults
-to True.</p>
-</dd>
-<dt>shape<span class="classifier">int or sequence of ints, optional.</span></dt><dd><p>Overrides the shape of the result. If order=’K’ and the number of
-dimensions is unchanged, will try to keep order, otherwise,
-order=’C’ is implied.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.17.0.</span></p>
-</div>
-</dd>
-</dl>
-</section>
-<section id="id198">
-<h3>Returns<a class="headerlink" href="#id198" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray</span></dt><dd><p>Array of ones with the same shape and type as <cite>a</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id199">
-<h3>See Also<a class="headerlink" href="#id199" title="Link to this heading"></a></h3>
-<p>empty_like : Return an empty array with shape and type of input.
-zeros_like : Return an array of zeros with shape and type of input.
-full_like : Return a new array with shape of input filled with value.
-ones : Return a new array setting values to one.</p>
-</section>
-<section id="id200">
-<h3>Examples<a class="headerlink" href="#id200" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
-<span class="go">array([[0, 1, 2],</span>
-<span class="go">       [3, 4, 5]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ones_like</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
-<span class="go">array([[1, 1, 1],</span>
-<span class="go">       [1, 1, 1]])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">float</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span>
-<span class="go">array([0., 1., 2.])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ones_like</span><span class="p">(</span><span class="n">y</span><span class="p">)</span>
-<span class="go">array([1.,  1.,  1.])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.ptp">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">ptp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.ptp" title="Link to this definition"></a></dt>
-<dd><p>Range of values (maximum - minimum) along an axis.</p>
-<p>The name of the function comes from the acronym for ‘peak to peak’.</p>
-<div class="admonition warning">
-<p class="admonition-title">Warning</p>
-<p><cite>ptp</cite> preserves the data type of the array. This means the
-return value for an input of signed integers with n bits
-(e.g. <cite>np.int8</cite>, <cite>np.int16</cite>, etc) is also a signed integer
-with n bits.  In that case, peak-to-peak values greater than
-<code class="docutils literal notranslate"><span class="pre">2**(n-1)-1</span></code> will be returned as negative values. An example
-with a work-around is shown below.</p>
-</div>
-<section id="id201">
-<h3>Parameters<a class="headerlink" href="#id201" title="Link to this heading"></a></h3>
-<dl>
-<dt>a<span class="classifier">array_like</span></dt><dd><p>Input values.</p>
-</dd>
-<dt>axis<span class="classifier">None or int or tuple of ints, optional</span></dt><dd><p>Axis along which to find the peaks.  By default, flatten the
-array.  <cite>axis</cite> may be negative, in
-which case it counts from the last to the first axis.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.15.0.</span></p>
-</div>
-<p>If this is a tuple of ints, a reduction is performed on multiple
-axes, instead of a single axis or all the axes as before.</p>
-</dd>
-<dt>out<span class="classifier">array_like</span></dt><dd><p>Alternative output array in which to place the result. It must
-have the same shape and buffer length as the expected output,
-but the type of the output values will be cast if necessary.</p>
-</dd>
-<dt>keepdims<span class="classifier">bool, optional</span></dt><dd><p>If this is set to True, the axes which are reduced are left
-in the result as dimensions with size one. With this option,
-the result will broadcast correctly against the input array.</p>
-<p>If the default value is passed, then <cite>keepdims</cite> will not be
-passed through to the <cite>ptp</cite> method of sub-classes of
-<cite>ndarray</cite>, however any non-default value will be.  If the
-sub-class’ method does not implement <cite>keepdims</cite> any
-exceptions will be raised.</p>
-</dd>
-</dl>
-</section>
-<section id="id202">
-<h3>Returns<a class="headerlink" href="#id202" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>ptp<span class="classifier">ndarray or scalar</span></dt><dd><p>The range of a given array - <cite>scalar</cite> if array is one-dimensional
-or a new array holding the result along the given axis</p>
-</dd>
-</dl>
-</section>
-<section id="id203">
-<h3>Examples<a class="headerlink" href="#id203" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">10</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="mi">6</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">12</span><span class="p">]])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ptp</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">array([8, 6])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ptp</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
-<span class="go">array([2, 0, 5, 2])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ptp</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
-<span class="go">10</span>
-</pre></div>
-</div>
-<p>This example shows that a negative value can be returned when
-the input is an array of signed integers.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">127</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">127</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">127</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">127</span><span class="p">]],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">np</span><span class="o">.</span><span class="n">int8</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ptp</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">array([ 126,  127, -128, -127], dtype=int8)</span>
-</pre></div>
-</div>
-<p>A work-around is to use the <cite>view()</cite> method to view the result as
-unsigned integers with the same bit width:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ptp</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">uint8</span><span class="p">)</span>
-<span class="go">array([126, 127, 128, 129], dtype=uint8)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.ravel">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">ravel</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'C'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.ravel" title="Link to this definition"></a></dt>
-<dd><p>Return a contiguous flattened array.</p>
-<p>A 1-D array, containing the elements of the input, is returned.  A copy is
-made only if needed.</p>
-<p>As of NumPy 1.10, the returned array will have the same type as the input
-array. (for example, a masked array will be returned for a masked array
-input)</p>
-<section id="id204">
-<h3>Parameters<a class="headerlink" href="#id204" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>a<span class="classifier">array_like</span></dt><dd><p>Input array.  The elements in <cite>a</cite> are read in the order specified by
-<cite>order</cite>, and packed as a 1-D array.</p>
-</dd>
-</dl>
-<p>order : {‘C’,’F’, ‘A’, ‘K’}, optional</p>
-<blockquote>
-<div><p>The elements of <cite>a</cite> are read using this index order. ‘C’ means
-to index the elements in row-major, C-style order,
-with the last axis index changing fastest, back to the first
-axis index changing slowest.  ‘F’ means to index the elements
-in column-major, Fortran-style order, with the
-first index changing fastest, and the last index changing
-slowest. Note that the ‘C’ and ‘F’ options take no account of
-the memory layout of the underlying array, and only refer to
-the order of axis indexing.  ‘A’ means to read the elements in
-Fortran-like index order if <cite>a</cite> is Fortran <em>contiguous</em> in
-memory, C-like order otherwise.  ‘K’ means to read the
-elements in the order they occur in memory, except for
-reversing the data when strides are negative.  By default, ‘C’
-index order is used.</p>
-</div></blockquote>
-</section>
-<section id="id205">
-<h3>Returns<a class="headerlink" href="#id205" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">array_like</span></dt><dd><p>y is a contiguous 1-D array of the same subtype as <cite>a</cite>,
-with shape <code class="docutils literal notranslate"><span class="pre">(a.size,)</span></code>.
-Note that matrices are special cased for backward compatibility,
-if <cite>a</cite> is a matrix, then y is a 1-D ndarray.</p>
-</dd>
-</dl>
-</section>
-<section id="id206">
-<h3>See Also<a class="headerlink" href="#id206" title="Link to this heading"></a></h3>
-<p>ndarray.flat : 1-D iterator over an array.
-ndarray.flatten : 1-D array copy of the elements of an array</p>
-<blockquote>
-<div><p>in row-major order.</p>
-</div></blockquote>
-<p>ndarray.reshape : Change the shape of an array without changing its data.</p>
-</section>
-<section id="id207">
-<h3>Notes<a class="headerlink" href="#id207" title="Link to this heading"></a></h3>
-<p>In row-major, C-style order, in two dimensions, the row index
-varies the slowest, and the column index the quickest.  This can
-be generalized to multiple dimensions, where row-major order
-implies that the index along the first axis varies slowest, and
-the index along the last quickest.  The opposite holds for
-column-major, Fortran-style index ordering.</p>
-<p>When a view is desired in as many cases as possible, <code class="docutils literal notranslate"><span class="pre">arr.reshape(-1)</span></code>
-may be preferable. However, <code class="docutils literal notranslate"><span class="pre">ravel</span></code> supports <code class="docutils literal notranslate"><span class="pre">K</span></code> in the optional
-<code class="docutils literal notranslate"><span class="pre">order</span></code> argument while <code class="docutils literal notranslate"><span class="pre">reshape</span></code> does not.</p>
-</section>
-<section id="id208">
-<h3>Examples<a class="headerlink" href="#id208" title="Link to this heading"></a></h3>
-<p>It is equivalent to <code class="docutils literal notranslate"><span class="pre">reshape(-1,</span> <span class="pre">order=order)</span></code>.</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
-<span class="go">array([1, 2, 3, 4, 5, 6])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
-<span class="go">array([1, 2, 3, 4, 5, 6])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="s1">&#39;F&#39;</span><span class="p">)</span>
-<span class="go">array([1, 4, 2, 5, 3, 6])</span>
-</pre></div>
-</div>
-<p>When <code class="docutils literal notranslate"><span class="pre">order</span></code> is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">x</span><span class="o">.</span><span class="n">T</span><span class="p">)</span>
-<span class="go">array([1, 4, 2, 5, 3, 6])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">x</span><span class="o">.</span><span class="n">T</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="s1">&#39;A&#39;</span><span class="p">)</span>
-<span class="go">array([1, 2, 3, 4, 5, 6])</span>
-</pre></div>
-</div>
-<p>When <code class="docutils literal notranslate"><span class="pre">order</span></code> is ‘K’, it will preserve orderings that are neither ‘C’
-nor ‘F’, but won’t reverse axes:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">)[::</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span> <span class="n">a</span>
-<span class="go">array([2, 1, 0])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">order</span><span class="o">=</span><span class="s1">&#39;C&#39;</span><span class="p">)</span>
-<span class="go">array([2, 1, 0])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">order</span><span class="o">=</span><span class="s1">&#39;K&#39;</span><span class="p">)</span>
-<span class="go">array([2, 1, 0])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">12</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">);</span> <span class="n">a</span>
-<span class="go">array([[[ 0,  2,  4],</span>
-<span class="go">        [ 1,  3,  5]],</span>
-<span class="go">       [[ 6,  8, 10],</span>
-<span class="go">        [ 7,  9, 11]]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">order</span><span class="o">=</span><span class="s1">&#39;C&#39;</span><span class="p">)</span>
-<span class="go">array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">ravel</span><span class="p">(</span><span class="n">order</span><span class="o">=</span><span class="s1">&#39;K&#39;</span><span class="p">)</span>
-<span class="go">array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.register_new_unit">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">register_new_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">u</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/fundamentalunits.html#register_new_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.register_new_unit" title="Link to this definition"></a></dt>
-<dd><p>Register a new unit for automatic displaying of quantities</p>
-<section id="id209">
-<h3>Parameters<a class="headerlink" href="#id209" title="Link to this heading"></a></h3>
-<dl>
-<dt>u<span class="classifier"><cite>Unit</cite></span></dt><dd><p>The unit that should be registered.</p>
-</dd>
-</dl>
-</section>
-<section id="id210">
-<h3>Examples<a class="headerlink" href="#id210" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="mf">2.0</span><span class="o">*</span><span class="n">farad</span><span class="o">/</span><span class="n">metre</span><span class="o">**</span><span class="mi">2</span>
-<span class="go">2. * metre ** -4 * kilogram ** -1 * second ** 4 * amp ** 2</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">register_new_unit</span><span class="p">(</span><span class="n">pfarad</span> <span class="o">/</span> <span class="n">mmetre</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="mf">2.0</span><span class="o">*</span><span class="n">farad</span><span class="o">/</span><span class="n">metre</span><span class="o">**</span><span class="mi">2</span>
-<span class="go">2000000. * pfarad / (mmetre ** 2)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.sin">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">sin</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.sin" title="Link to this definition"></a></dt>
-<dd><p>Trigonometric sine, element-wise.</p>
-<section id="id211">
-<h3>Parameters<a class="headerlink" href="#id211" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Angle, in radians (<span class="math notranslate nohighlight">\(2 \pi\)</span> rad equals 360 degrees).</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id212"><span class="problematic" id="id213">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id214">
-<h3>Returns<a class="headerlink" href="#id214" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">array_like</span></dt><dd><p>The sine of each element of x.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id215">
-<h3>See Also<a class="headerlink" href="#id215" title="Link to this heading"></a></h3>
-<p>arcsin, sinh, cos</p>
-</section>
-<section id="id216">
-<h3>Notes<a class="headerlink" href="#id216" title="Link to this heading"></a></h3>
-<p>The sine is one of the fundamental functions of trigonometry (the
-mathematical study of triangles).  Consider a circle of radius 1
-centered on the origin.  A ray comes in from the <span class="math notranslate nohighlight">\(+x\)</span> axis, makes
-an angle at the origin (measured counter-clockwise from that axis), and
-departs from the origin.  The <span class="math notranslate nohighlight">\(y\)</span> coordinate of the outgoing
-ray’s intersection with the unit circle is the sine of that angle.  It
-ranges from -1 for <span class="math notranslate nohighlight">\(x=3\pi / 2\)</span> to +1 for <span class="math notranslate nohighlight">\(\pi / 2.\)</span>  The
-function has zeroes where the angle is a multiple of <span class="math notranslate nohighlight">\(\pi\)</span>.
-Sines of angles between <span class="math notranslate nohighlight">\(\pi\)</span> and <span class="math notranslate nohighlight">\(2\pi\)</span> are negative.
-The numerous properties of the sine and related functions are included
-in any standard trigonometry text.</p>
-</section>
-<section id="id217">
-<h3>Examples<a class="headerlink" href="#id217" title="Link to this heading"></a></h3>
-<p>Print sine of one angle:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">/</span><span class="mf">2.</span><span class="p">)</span>
-<span class="go">1.0</span>
-</pre></div>
-</div>
-<p>Print sines of an array of angles given in degrees:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">((</span><span class="mf">0.</span><span class="p">,</span> <span class="mf">30.</span><span class="p">,</span> <span class="mf">45.</span><span class="p">,</span> <span class="mf">60.</span><span class="p">,</span> <span class="mf">90.</span><span class="p">))</span> <span class="o">*</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span> <span class="o">/</span> <span class="mf">180.</span> <span class="p">)</span>
-<span class="go">array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])</span>
-</pre></div>
-</div>
-<p>Plot the sine function:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">matplotlib.pylab</span> <span class="k">as</span> <span class="nn">plt</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="mi">201</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">xlabel</span><span class="p">(</span><span class="s1">&#39;Angle [rad]&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">ylabel</span><span class="p">(</span><span class="s1">&#39;sin(x)&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">axis</span><span class="p">(</span><span class="s1">&#39;tight&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.sinh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">sinh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.sinh" title="Link to this definition"></a></dt>
-<dd><p>Hyperbolic sine, element-wise.</p>
-<p>Equivalent to <code class="docutils literal notranslate"><span class="pre">1/2</span> <span class="pre">*</span> <span class="pre">(np.exp(x)</span> <span class="pre">-</span> <span class="pre">np.exp(-x))</span></code> or
-<code class="docutils literal notranslate"><span class="pre">-1j</span> <span class="pre">*</span> <span class="pre">np.sin(1j*x)</span></code>.</p>
-<section id="id218">
-<h3>Parameters<a class="headerlink" href="#id218" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id219"><span class="problematic" id="id220">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id221">
-<h3>Returns<a class="headerlink" href="#id221" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The corresponding hyperbolic sine values.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id222">
-<h3>Notes<a class="headerlink" href="#id222" title="Link to this heading"></a></h3>
-<p>If <cite>out</cite> is provided, the function writes the result into it,
-and returns a reference to <cite>out</cite>.  (See Examples)</p>
-</section>
-<section id="id223">
-<h3>References<a class="headerlink" href="#id223" title="Link to this heading"></a></h3>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972, pg. 83.</p>
-</section>
-<section id="id224">
-<h3>Examples<a class="headerlink" href="#id224" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sinh</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="go">0.0</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sinh</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="mi">1</span><span class="n">j</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span>
-<span class="go">1j</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sinh</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="mi">1</span><span class="n">j</span><span class="p">)</span> <span class="c1"># (exact value is 0)</span>
-<span class="go">1.2246063538223773e-016j</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Discrepancy due to vagaries of floating point arithmetic.</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of providing the optional output parameter</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">0</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="s1">&#39;d&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">sinh</span><span class="p">([</span><span class="mf">0.1</span><span class="p">],</span> <span class="n">out1</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="ow">is</span> <span class="n">out1</span>
-<span class="go">True</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of ValueError due to provision of shape mis-matched `out`</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">sinh</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)),</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)))</span>
-<span class="gt">Traceback (most recent call last):</span>
-  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n">&lt;module&gt;</span>
-<span class="gr">ValueError</span>: <span class="n">operands could not be broadcast together with shapes (3,3) (2,2)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.tan">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">tan</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.tan" title="Link to this definition"></a></dt>
-<dd><p>Compute tangent element-wise.</p>
-<p>Equivalent to <code class="docutils literal notranslate"><span class="pre">np.sin(x)/np.cos(x)</span></code> element-wise.</p>
-<section id="id225">
-<h3>Parameters<a class="headerlink" href="#id225" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id226"><span class="problematic" id="id227">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id228">
-<h3>Returns<a class="headerlink" href="#id228" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The corresponding tangent values.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id229">
-<h3>Notes<a class="headerlink" href="#id229" title="Link to this heading"></a></h3>
-<p>If <cite>out</cite> is provided, the function writes the result into it,
-and returns a reference to <cite>out</cite>.  (See Examples)</p>
-</section>
-<section id="id230">
-<h3>References<a class="headerlink" href="#id230" title="Link to this heading"></a></h3>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972.</p>
-</section>
-<section id="id231">
-<h3>Examples<a class="headerlink" href="#id231" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">pi</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">tan</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="o">-</span><span class="n">pi</span><span class="p">,</span><span class="n">pi</span><span class="o">/</span><span class="mi">2</span><span class="p">,</span><span class="n">pi</span><span class="p">]))</span>
-<span class="go">array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])</span>
-<span class="gp">&gt;&gt;&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of providing the optional output parameter illustrating</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># that what is returned is a reference to said parameter</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">0</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="s1">&#39;d&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">cos</span><span class="p">([</span><span class="mf">0.1</span><span class="p">],</span> <span class="n">out1</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="ow">is</span> <span class="n">out1</span>
-<span class="go">True</span>
-<span class="gp">&gt;&gt;&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of ValueError due to provision of shape mis-matched `out`</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)),</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)))</span>
-<span class="gt">Traceback (most recent call last):</span>
-  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n">&lt;module&gt;</span>
-<span class="gr">ValueError</span>: <span class="n">operands could not be broadcast together with shapes (3,3) (2,2)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.tanh">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">tanh</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">where=True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">casting='same_kind'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order='K'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subok=True</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">signature</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">extobj</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.tanh" title="Link to this definition"></a></dt>
-<dd><p>Compute hyperbolic tangent element-wise.</p>
-<p>Equivalent to <code class="docutils literal notranslate"><span class="pre">np.sinh(x)/np.cosh(x)</span></code> or <code class="docutils literal notranslate"><span class="pre">-1j</span> <span class="pre">*</span> <span class="pre">np.tan(1j*x)</span></code>.</p>
-<section id="id232">
-<h3>Parameters<a class="headerlink" href="#id232" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>x<span class="classifier">array_like</span></dt><dd><p>Input array.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, None, or tuple of ndarray and None, optional</span></dt><dd><p>A location into which the result is stored. If provided, it must have
-a shape that the inputs broadcast to. If not provided or None,
-a freshly-allocated array is returned. A tuple (possible only as a
-keyword argument) must have length equal to the number of outputs.</p>
-</dd>
-<dt>where<span class="classifier">array_like, optional</span></dt><dd><p>This condition is broadcast over the input. At locations where the
-condition is True, the <cite>out</cite> array will be set to the ufunc result.
-Elsewhere, the <cite>out</cite> array will retain its original value.
-Note that if an uninitialized <cite>out</cite> array is created via the default
-<code class="docutils literal notranslate"><span class="pre">out=None</span></code>, locations within it where the condition is False will
-remain uninitialized.</p>
-</dd>
-<dt><a href="#id233"><span class="problematic" id="id234">**</span></a>kwargs</dt><dd><p>For other keyword-only arguments, see the
-<span class="xref std std-ref">ufunc docs</span>.</p>
-</dd>
-</dl>
-</section>
-<section id="id235">
-<h3>Returns<a class="headerlink" href="#id235" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>y<span class="classifier">ndarray</span></dt><dd><p>The corresponding hyperbolic tangent values.
-This is a scalar if <cite>x</cite> is a scalar.</p>
-</dd>
-</dl>
-</section>
-<section id="id236">
-<h3>Notes<a class="headerlink" href="#id236" title="Link to this heading"></a></h3>
-<p>If <cite>out</cite> is provided, the function writes the result into it,
-and returns a reference to <cite>out</cite>.  (See Examples)</p>
-</section>
-<section id="id237">
-<h3>References<a class="headerlink" href="#id237" title="Link to this heading"></a></h3>
-<aside class="footnote-list brackets">
-<aside class="footnote brackets" id="id238" role="note">
-<span class="label"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></span>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972, pg. 83.
-<a class="reference external" href="https://personal.math.ubc.ca/~cbm/aands/page_83.htm">https://personal.math.ubc.ca/~cbm/aands/page_83.htm</a></p>
-</aside>
-<aside class="footnote brackets" id="id239" role="note">
-<span class="label"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></span>
-<p>Wikipedia, “Hyperbolic function”,
-<a class="reference external" href="https://en.wikipedia.org/wiki/Hyperbolic_function">https://en.wikipedia.org/wiki/Hyperbolic_function</a></p>
-</aside>
-</aside>
-</section>
-<section id="id240">
-<h3>Examples<a class="headerlink" href="#id240" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">tanh</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="mi">1</span><span class="n">j</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="mi">1</span><span class="n">j</span><span class="o">/</span><span class="mi">2</span><span class="p">))</span>
-<span class="go">array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of providing the optional output parameter illustrating</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="c1"># that what is returned is a reference to said parameter</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out1</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">0</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="s1">&#39;d&#39;</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">tanh</span><span class="p">([</span><span class="mf">0.1</span><span class="p">],</span> <span class="n">out1</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">out2</span> <span class="ow">is</span> <span class="n">out1</span>
-<span class="go">True</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Example of ValueError due to provision of shape mis-matched `out`</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">tanh</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)),</span><span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)))</span>
-<span class="gt">Traceback (most recent call last):</span>
-  File <span class="nb">&quot;&lt;stdin&gt;&quot;</span>, line <span class="m">1</span>, in <span class="n">&lt;module&gt;</span>
-<span class="gr">ValueError</span>: <span class="n">operands could not be broadcast together with shapes (3,3) (2,2)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.trace">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">trace</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">offset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis1</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">axis2</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dtype</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">out</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.trace" title="Link to this definition"></a></dt>
-<dd><p>Return the sum along diagonals of the array.</p>
-<p>If <cite>a</cite> is 2-D, the sum along its diagonal with the given offset
-is returned, i.e., the sum of elements <code class="docutils literal notranslate"><span class="pre">a[i,i+offset]</span></code> for all i.</p>
-<p>If <cite>a</cite> has more than two dimensions, then the axes specified by axis1 and
-axis2 are used to determine the 2-D sub-arrays whose traces are returned.
-The shape of the resulting array is the same as that of <cite>a</cite> with <cite>axis1</cite>
-and <cite>axis2</cite> removed.</p>
-<section id="id241">
-<h3>Parameters<a class="headerlink" href="#id241" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>a<span class="classifier">array_like</span></dt><dd><p>Input array, from which the diagonals are taken.</p>
-</dd>
-<dt>offset<span class="classifier">int, optional</span></dt><dd><p>Offset of the diagonal from the main diagonal. Can be both positive
-and negative. Defaults to 0.</p>
-</dd>
-<dt>axis1, axis2<span class="classifier">int, optional</span></dt><dd><p>Axes to be used as the first and second axis of the 2-D sub-arrays
-from which the diagonals should be taken. Defaults are the first two
-axes of <cite>a</cite>.</p>
-</dd>
-<dt>dtype<span class="classifier">dtype, optional</span></dt><dd><p>Determines the data-type of the returned array and of the accumulator
-where the elements are summed. If dtype has the value None and <cite>a</cite> is
-of integer type of precision less than the default integer
-precision, then the default integer precision is used. Otherwise,
-the precision is the same as that of <cite>a</cite>.</p>
-</dd>
-<dt>out<span class="classifier">ndarray, optional</span></dt><dd><p>Array into which the output is placed. Its type is preserved and
-it must be of the right shape to hold the output.</p>
-</dd>
-</dl>
-</section>
-<section id="id242">
-<h3>Returns<a class="headerlink" href="#id242" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>sum_along_diagonals<span class="classifier">ndarray</span></dt><dd><p>If <cite>a</cite> is 2-D, the sum along the diagonal is returned.  If <cite>a</cite> has
-larger dimensions, then an array of sums along diagonals is returned.</p>
-</dd>
-</dl>
-</section>
-<section id="id243">
-<h3>See Also<a class="headerlink" href="#id243" title="Link to this heading"></a></h3>
-<p>diag, diagonal, diagflat</p>
-</section>
-<section id="id244">
-<h3>Examples<a class="headerlink" href="#id244" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
-<span class="go">3.0</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
-<span class="go">array([6, 8])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">24</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span>
-<span class="go">(2, 3)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.where">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">where</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">condition</span></span></em>, <span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">y</span></span></em>, <span class="optional">]</span><em class="sig-param"><span class="n"><span class="pre">/</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/unitSI/unitsafefunctions.html#where"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#unitSI.where" title="Link to this definition"></a></dt>
-<dd><p>Return elements chosen from <cite>x</cite> or <cite>y</cite> depending on <cite>condition</cite>.</p>
-<div class="admonition note">
-<p class="admonition-title">Note</p>
-<p>When only <cite>condition</cite> is provided, this function is a shorthand for
-<code class="docutils literal notranslate"><span class="pre">np.asarray(condition).nonzero()</span></code>. Using <cite>nonzero</cite> directly should be
-preferred, as it behaves correctly for subclasses. The rest of this
-documentation covers only the case where all three arguments are
-provided.</p>
-</div>
-<section id="id245">
-<h3>Parameters<a class="headerlink" href="#id245" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>condition<span class="classifier">array_like, bool</span></dt><dd><p>Where True, yield <cite>x</cite>, otherwise yield <cite>y</cite>.</p>
-</dd>
-<dt>x, y<span class="classifier">array_like</span></dt><dd><p>Values from which to choose. <cite>x</cite>, <cite>y</cite> and <cite>condition</cite> need to be
-broadcastable to some shape.</p>
-</dd>
-</dl>
-</section>
-<section id="id246">
-<h3>Returns<a class="headerlink" href="#id246" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray</span></dt><dd><p>An array with elements from <cite>x</cite> where <cite>condition</cite> is True, and elements
-from <cite>y</cite> elsewhere.</p>
-</dd>
-</dl>
-</section>
-<section id="id247">
-<h3>See Also<a class="headerlink" href="#id247" title="Link to this heading"></a></h3>
-<p>choose
-nonzero : The function that is called when x and y are omitted</p>
-</section>
-<section id="id248">
-<h3>Notes<a class="headerlink" href="#id248" title="Link to this heading"></a></h3>
-<p>If all the arrays are 1-D, <cite>where</cite> is equivalent to:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">xv</span> <span class="k">if</span> <span class="n">c</span> <span class="k">else</span> <span class="n">yv</span>
- <span class="k">for</span> <span class="n">c</span><span class="p">,</span> <span class="n">xv</span><span class="p">,</span> <span class="n">yv</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">condition</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)]</span>
-</pre></div>
-</div>
-</section>
-<section id="id249">
-<h3>Examples<a class="headerlink" href="#id249" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
-<span class="go">array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">a</span> <span class="o">&lt;</span> <span class="mi">5</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="mi">10</span><span class="o">*</span><span class="n">a</span><span class="p">)</span>
-<span class="go">array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])</span>
-</pre></div>
-</div>
-<p>This can be used on multidimensional arrays too:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">where</span><span class="p">([[</span><span class="kc">True</span><span class="p">,</span> <span class="kc">False</span><span class="p">],</span> <span class="p">[</span><span class="kc">True</span><span class="p">,</span> <span class="kc">True</span><span class="p">]],</span>
-<span class="gp">... </span>         <span class="p">[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]],</span>
-<span class="gp">... </span>         <span class="p">[[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">8</span><span class="p">],</span> <span class="p">[</span><span class="mi">7</span><span class="p">,</span> <span class="mi">6</span><span class="p">]])</span>
-<span class="go">array([[1, 8],</span>
-<span class="go">       [3, 4]])</span>
-</pre></div>
-</div>
-<p>The shapes of x, y, and the condition are broadcast together:</p>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">ogrid</span><span class="p">[:</span><span class="mi">3</span><span class="p">,</span> <span class="p">:</span><span class="mi">4</span><span class="p">]</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">x</span> <span class="o">&lt;</span> <span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="mi">10</span> <span class="o">+</span> <span class="n">y</span><span class="p">)</span>  <span class="c1"># both x and 10+y are broadcast</span>
-<span class="go">array([[10,  0,  0,  0],</span>
-<span class="go">       [10, 11,  1,  1],</span>
-<span class="go">       [10, 11, 12,  2]])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span>
-<span class="gp">... </span>              <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">6</span><span class="p">]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">a</span> <span class="o">&lt;</span> <span class="mi">4</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>  <span class="c1"># -1 is broadcast</span>
-<span class="go">array([[ 0,  1,  2],</span>
-<span class="go">       [ 0,  2, -1],</span>
-<span class="go">       [ 0,  3, -1]])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="unitSI.zeros_like">
-<span class="sig-prename descclassname"><span class="pre">unitSI.</span></span><span class="sig-name descname"><span class="pre">zeros_like</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#unitSI.zeros_like" title="Link to this definition"></a></dt>
-<dd><p>Return an array of zeros with the same shape and type as a given array.</p>
-<section id="id250">
-<h3>Parameters<a class="headerlink" href="#id250" title="Link to this heading"></a></h3>
-<dl>
-<dt>a<span class="classifier">array_like</span></dt><dd><p>The shape and data-type of <cite>a</cite> define these same attributes of
-the returned array.</p>
-</dd>
-<dt>dtype<span class="classifier">data-type, optional</span></dt><dd><p>Overrides the data type of the result.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.6.0.</span></p>
-</div>
-</dd>
-<dt>order<span class="classifier">{‘C’, ‘F’, ‘A’, or ‘K’}, optional</span></dt><dd><p>Overrides the memory layout of the result. ‘C’ means C-order,
-‘F’ means F-order, ‘A’ means ‘F’ if <cite>a</cite> is Fortran contiguous,
-‘C’ otherwise. ‘K’ means match the layout of <cite>a</cite> as closely
-as possible.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.6.0.</span></p>
-</div>
-</dd>
-<dt>subok<span class="classifier">bool, optional.</span></dt><dd><p>If True, then the newly created array will use the sub-class
-type of <cite>a</cite>, otherwise it will be a base-class array. Defaults
-to True.</p>
-</dd>
-<dt>shape<span class="classifier">int or sequence of ints, optional.</span></dt><dd><p>Overrides the shape of the result. If order=’K’ and the number of
-dimensions is unchanged, will try to keep order, otherwise,
-order=’C’ is implied.</p>
-<div class="versionadded">
-<p><span class="versionmodified added">Added in version 1.17.0.</span></p>
-</div>
-</dd>
-</dl>
-</section>
-<section id="id251">
-<h3>Returns<a class="headerlink" href="#id251" title="Link to this heading"></a></h3>
-<dl class="simple">
-<dt>out<span class="classifier">ndarray</span></dt><dd><p>Array of zeros with the same shape and type as <cite>a</cite>.</p>
-</dd>
-</dl>
-</section>
-<section id="id252">
-<h3>See Also<a class="headerlink" href="#id252" title="Link to this heading"></a></h3>
-<p>empty_like : Return an empty array with shape and type of input.
-ones_like : Return an array of ones with shape and type of input.
-full_like : Return a new array with shape of input filled with value.
-zeros : Return a new array setting values to zero.</p>
-</section>
-<section id="id253">
-<h3>Examples<a class="headerlink" href="#id253" title="Link to this heading"></a></h3>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">))</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
-<span class="go">array([[0, 1, 2],</span>
-<span class="go">       [3, 4, 5]])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">zeros_like</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
-<span class="go">array([[0, 0, 0],</span>
-<span class="go">       [0, 0, 0]])</span>
-</pre></div>
-</div>
-<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">float</span><span class="p">)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span>
-<span class="go">array([0., 1., 2.])</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">zeros_like</span><span class="p">(</span><span class="n">y</span><span class="p">)</span>
-<span class="go">array([0.,  0.,  0.])</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
+<section id="module-contents">
+<h2>Module contents<a class="headerlink" href="#module-contents" title="Link to this heading"></a></h2>
 </section>
 </section>
 
diff --git a/docs_sphinx/_build/html/unitSI.stdunits.html b/docs_sphinx/_build/html/unitSI.stdunits.html
index 8191c97..6e07c54 100644
--- a/docs_sphinx/_build/html/unitSI.stdunits.html
+++ b/docs_sphinx/_build/html/unitSI.stdunits.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
@@ -57,7 +59,7 @@
 <li class="toctree-l4"><a class="reference internal" href="unitSI.unitsafefunctions.html">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.tests.html b/docs_sphinx/_build/html/unitSI.tests.html
index 99b5088..1097c40 100644
--- a/docs_sphinx/_build/html/unitSI.tests.html
+++ b/docs_sphinx/_build/html/unitSI.tests.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3 current"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a><ul class="current">
@@ -53,7 +55,7 @@
 </ul>
 </li>
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#submodules">Submodules</a></li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.tests.test_units.html b/docs_sphinx/_build/html/unitSI.tests.test_units.html
index 2be21b3..50a4488 100644
--- a/docs_sphinx/_build/html/unitSI.tests.test_units.html
+++ b/docs_sphinx/_build/html/unitSI.tests.test_units.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3 current"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a><ul class="current">
@@ -53,7 +55,7 @@
 </ul>
 </li>
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#submodules">Submodules</a></li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/unitSI.unitsafefunctions.html b/docs_sphinx/_build/html/unitSI.unitsafefunctions.html
index 2d8c750..959b5fd 100644
--- a/docs_sphinx/_build/html/unitSI.unitsafefunctions.html
+++ b/docs_sphinx/_build/html/unitSI.unitsafefunctions.html
@@ -46,6 +46,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
 <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="user/units.html">Physical units</a></li>
+<li class="toctree-l1"><a class="reference internal" href="developer/units.html">Units</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="modules.html">unitSI</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="unitSI.html">unitSI package</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="unitSI.html#subpackages">Subpackages</a></li>
@@ -57,7 +59,7 @@
 <li class="toctree-l4 current"><a class="current reference internal" href="#">unitSI.unitsafefunctions module</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-unitSI">Module contents</a></li>
+<li class="toctree-l3"><a class="reference internal" href="unitSI.html#module-contents">Module contents</a></li>
 </ul>
 </li>
 </ul>
diff --git a/docs_sphinx/_build/html/user/units.html b/docs_sphinx/_build/html/user/units.html
index f2addb2..5287e8c 100644
--- a/docs_sphinx/_build/html/user/units.html
+++ b/docs_sphinx/_build/html/user/units.html
@@ -21,7 +21,9 @@
         <script async="async" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
     <script src="../_static/js/theme.js"></script>
     <link rel="index" title="Index" href="../genindex.html" />
-    <link rel="search" title="Search" href="../search.html" /> 
+    <link rel="search" title="Search" href="../search.html" />
+    <link rel="next" title="Units" href="../developer/units.html" />
+    <link rel="prev" title="Welcome to unitSI’s documentation!" href="../index.html" /> 
 </head>
 
 <body class="wy-body-for-nav"> 
@@ -44,7 +46,17 @@
 </div>
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Contents:</span></p>
-<ul>
+<ul class="current">
+<li class="toctree-l1 current"><a class="current reference internal" href="#">Physical units</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="#using-units">Using units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#removing-units">Removing units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#temperatures">Temperatures</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#constants">Constants</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#importing-units">Importing units</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#in-place-operations-on-quantities">In-place operations on quantities</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="../developer/units.html">Units</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../modules.html">unitSI</a></li>
 </ul>
 
@@ -84,10 +96,10 @@ <h1>Physical units<a class="headerlink" href="#physical-units" title="Link to th
 <li><p><a class="reference internal" href="#in-place-operations-on-quantities" id="id8">In-place operations on quantities</a></p></li>
 </ul>
 </nav>
-<p>Brian includes a system for physical units. The base units are defined by their
+<p>unitSI is a system for physical units. The base units are defined by their
 standard SI unit names: <code class="docutils literal notranslate"><span class="pre">amp</span></code>/<code class="docutils literal notranslate"><span class="pre">ampere</span></code>, <code class="docutils literal notranslate"><span class="pre">kilogram</span></code>/<code class="docutils literal notranslate"><span class="pre">kilogramme</span></code>,
 <code class="docutils literal notranslate"><span class="pre">second</span></code>, <code class="docutils literal notranslate"><span class="pre">metre</span></code>/<code class="docutils literal notranslate"><span class="pre">meter</span></code>, <code class="docutils literal notranslate"><span class="pre">mole</span></code>/<code class="docutils literal notranslate"><span class="pre">mol</span></code>, <code class="docutils literal notranslate"><span class="pre">kelvin</span></code>, and <code class="docutils literal notranslate"><span class="pre">candela</span></code>.
-In addition to these base units, Brian defines a set of derived units:
+In addition to these base units, unitSI defines a set of derived units:
 <code class="docutils literal notranslate"><span class="pre">coulomb</span></code>, <code class="docutils literal notranslate"><span class="pre">farad</span></code>, <code class="docutils literal notranslate"><span class="pre">gram</span></code>/<code class="docutils literal notranslate"><span class="pre">gramme</span></code>, <code class="docutils literal notranslate"><span class="pre">hertz</span></code>, <code class="docutils literal notranslate"><span class="pre">joule</span></code>, <code class="docutils literal notranslate"><span class="pre">liter</span></code>/
 <code class="docutils literal notranslate"><span class="pre">litre</span></code>, <code class="docutils literal notranslate"><span class="pre">molar</span></code>, <code class="docutils literal notranslate"><span class="pre">pascal</span></code>, <code class="docutils literal notranslate"><span class="pre">ohm</span></code>,  <code class="docutils literal notranslate"><span class="pre">siemens</span></code>, <code class="docutils literal notranslate"><span class="pre">volt</span></code>, <code class="docutils literal notranslate"><span class="pre">watt</span></code>,
 together with prefixed versions (e.g. <code class="docutils literal notranslate"><span class="pre">msiemens</span> <span class="pre">=</span> <span class="pre">0.001*siemens</span></code>) using the
@@ -112,7 +124,7 @@ <h2><a class="toc-backref" href="#id3" role="doc-backlink">Using units</a><a cla
 <span class="go">[ 10.  20.  30.] Hz</span>
 </pre></div>
 </div>
-<p>Brian will check the consistency of operations on units and raise an error for
+<p>unitSI will check the consistency of operations on units and raise an error for
 dimensionality mismatches:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">tau</span> <span class="o">+=</span> <span class="mi">1</span>  <span class="c1"># ms? second?  </span>
 <span class="gt">Traceback (most recent call last):</span>
@@ -124,7 +136,7 @@ <h2><a class="toc-backref" href="#id3" role="doc-backlink">Using units</a><a cla
 <span class="gr">DimensionMismatchError</span>: <span class="n">Cannot calculate 3. kg + 3. A, units do not match (units are kilogram and amp).</span>
 </pre></div>
 </div>
-<p>Most Brian functions will also complain about non-specified or incorrect units:</p>
+<p>In Brian functions will also complain about non-specified or incorrect units:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">G</span> <span class="o">=</span> <span class="n">NeuronGroup</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="s1">&#39;dv/dt = -v/tau: volt&#39;</span><span class="p">,</span> <span class="n">dt</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>   
 <span class="gt">Traceback (most recent call last):</span>
 <span class="c">...</span>
@@ -164,8 +176,8 @@ <h2><a class="toc-backref" href="#id4" role="doc-backlink">Removing units</a><a
 </section>
 <section id="temperatures">
 <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a class="headerlink" href="#temperatures" title="Link to this heading"></a></h2>
-<p>Brian only supports temperatures defined in °K, using the provided <code class="docutils literal notranslate"><span class="pre">kelvin</span></code>
-unit object. Other conventions such as °C, or °F are not compatible with Brian’s
+<p>unitSI only supports temperatures defined in °K, using the provided <code class="docutils literal notranslate"><span class="pre">kelvin</span></code>
+unit object. Other conventions such as °C, or °F are not compatible with unitSI
 unit system, because they cannot be expressed as a multiplicative scaling of the
 SI base unit kelvin (their zero point is different). However, in biological
 experiments and modeling, temperatures are typically reported in °C. How to use
@@ -181,9 +193,9 @@ <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a cl
 <dt>absolute temperatures</dt><dd><p>Equations such as the <a class="reference external" href="https://en.wikipedia.org/wiki/Goldman_equation">Goldman–Hodgkin–Katz voltage equation</a>
 have a factor that depends on the absolute temperature measured in Kelvin.
 To get this temperature from a temperature reported in °C, you can use the
-<code class="docutils literal notranslate"><span class="pre">zero_celsius</span></code> constant from the <cite>brian2.units.constants</cite> package (see
+<code class="docutils literal notranslate"><span class="pre">zero_celsius</span></code> constant from the <cite>unitSI.constants</cite> package (see
 below):</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">brian2.units.constants</span> <span class="kn">import</span> <span class="n">zero_celsius</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span>  <span class="nn">unitSI.constants</span> <span class="kn">import</span> <span class="n">zero_celsius</span>
 
 <span class="n">celsius_temp</span> <span class="o">=</span> <span class="mi">27</span>
 <span class="n">abs_temp</span> <span class="o">=</span> <span class="n">celsius_temp</span><span class="o">*</span><span class="n">kelvin</span> <span class="o">+</span> <span class="n">zero_celsius</span>
@@ -193,7 +205,7 @@ <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a cl
 </dl>
 <div class="admonition note">
 <p class="admonition-title">Note</p>
-<p>Earlier versions of Brian had a <code class="docutils literal notranslate"><span class="pre">celsius</span></code> unit which was in fact
+<p>Earlier versions of unitSI had a <code class="docutils literal notranslate"><span class="pre">celsius</span></code> unit which was in fact
 identical to <code class="docutils literal notranslate"><span class="pre">kelvin</span></code>. While this gave the correct results for
 temperature differences, it did not correctly work for absolute
 temperatures. To avoid confusion and possible misinterpretation,
@@ -202,14 +214,14 @@ <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a cl
 </section>
 <section id="constants">
 <span id="id1"></span><h2><a class="toc-backref" href="#id6" role="doc-backlink">Constants</a><a class="headerlink" href="#constants" title="Link to this heading"></a></h2>
-<p>The <cite>brian2.units.constants</cite> package provides a range of physical constants that
-can be useful for detailed biological models. Brian provides the following
+<p>The <cite>unitSI.constants</cite> package provides a range of physical constants that
+can be useful for detailed biological models. UnitSI provides the following
 constants:</p>
 <table class="docutils align-default">
 <thead>
 <tr class="row-odd"><th class="head"><p>Constant</p></th>
 <th class="head"><p>Symbol(s)</p></th>
-<th class="head"><p>Brian name</p></th>
+<th class="head"><p>unitSI name</p></th>
 <th class="head"><p>Value</p></th>
 </tr>
 </thead>
@@ -267,13 +279,13 @@ <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a cl
 </tbody>
 </table>
 <p>Note that these constants are not imported by default, you will have to
-explicitly import them from <cite>brian2.units.constants</cite>. During the import, you
+explicitly import them from <cite>unitSI.constants</cite>. During the import, you
 can also give them shorter names using Python’s <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">...</span> <span class="pre">import</span> <span class="pre">...</span> <span class="pre">as</span> <span class="pre">...</span></code>
 syntax. For example, to calculate the <span class="math notranslate nohighlight">\(\frac{RT}{F}\)</span> factor that appears
 in the <a class="reference external" href="https://en.wikipedia.org/wiki/Goldman_equation">Goldman–Hodgkin–Katz voltage equation</a>
 you can use:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">brian2</span> <span class="kn">import</span> <span class="o">*</span>
-<span class="kn">from</span> <span class="nn">brian2.units.constants</span> <span class="kn">import</span> <span class="n">zero_celsius</span><span class="p">,</span> <span class="n">gas_constant</span> <span class="k">as</span> <span class="n">R</span><span class="p">,</span> <span class="n">faraday_constant</span> <span class="k">as</span> <span class="n">F</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">unitSI</span> <span class="kn">import</span> <span class="o">*</span>
+<span class="kn">from</span> <span class="nn">unitSI.constants</span> <span class="kn">import</span> <span class="n">zero_celsius</span><span class="p">,</span> <span class="n">gas_constant</span> <span class="k">as</span> <span class="n">R</span><span class="p">,</span> <span class="n">faraday_constant</span> <span class="k">as</span> <span class="n">F</span>
 
 <span class="n">celsius_temp</span> <span class="o">=</span> <span class="mi">27</span>
 <span class="n">T</span> <span class="o">=</span> <span class="n">celsius_temp</span><span class="o">*</span><span class="n">kelvin</span> <span class="o">+</span> <span class="n">zero_celsius</span>
@@ -289,15 +301,14 @@ <h2><a class="toc-backref" href="#id5" role="doc-backlink">Temperatures</a><a cl
 </section>
 <section id="importing-units">
 <h2><a class="toc-backref" href="#id7" role="doc-backlink">Importing units</a><a class="headerlink" href="#importing-units" title="Link to this heading"></a></h2>
-<p>Brian generates standard names for units, combining the unit name (e.g.
+<p>unitSI generates standard names for units, combining the unit name (e.g.
 “siemens”) with a prefixes (e.g. “m”), and also generates squared and cubed
 versions by appending a number. For example, the units “msiemens”, “siemens2”,
 “usiemens3” are all predefined. You can import these units from the package
 <code class="docutils literal notranslate"><span class="pre">brian2.units.allunits</span></code> – accordingly, an
 <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">brian2.units.allunits</span> <span class="pre">import</span> <span class="pre">*</span></code> will result in everything from
 <code class="docutils literal notranslate"><span class="pre">Ylumen3</span></code> (cubed yotta lumen) to <code class="docutils literal notranslate"><span class="pre">ymol</span></code> (yocto mole) being imported.</p>
-<p>A better choice is normally to do <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">brian2.units</span> <span class="pre">import</span> <span class="pre">*</span></code> or import
-everything <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">brian2</span> <span class="pre">import</span> <span class="pre">*</span></code> which only imports the units mentioned in
+<p>A better choice is normally to do <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">unitSI</span> <span class="pre">import</span> <span class="pre">*</span></code> which only imports the units mentioned in
 the introductory paragraph (base units, derived units, and some standard
 abbreviations).</p>
 </section>
@@ -332,7 +343,10 @@ <h2><a class="toc-backref" href="#id8" role="doc-backlink">In-place operations o
 
            </div>
           </div>
-          <footer>
+          <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
+        <a href="../index.html" class="btn btn-neutral float-left" title="Welcome to unitSI’s documentation!" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
+        <a href="../developer/units.html" class="btn btn-neutral float-right" title="Units" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
+    </div>
 
   <hr/>
 
diff --git a/docs_sphinx/developer/units.rst b/docs_sphinx/developer/units.rst
index 216900f..98d2d5d 100644
--- a/docs_sphinx/developer/units.rst
+++ b/docs_sphinx/developer/units.rst
@@ -3,15 +3,8 @@ Units
 
 Casting rules
 -------------
-In Brian 1, a distinction is made between scalars and numpy arrays (including
-scalar arrays): Scalars could be multiplied with a unit, resulting in a Quantity
-object whereas the multiplication of an array with a unit resulted in a
-(unitless) array. Accordingly, scalars were considered as dimensionless
-quantities for the purpose of unit checking (e.g.. 1 + 1 * mV raised an error)
-whereas arrays were not (e.g. array(1) + 1 * mV resulted in 1.001 without any
-errors). Brian 2 no longer makes this distinction and treats both scalars and
-arrays as dimensionless for unit checking and make all operations involving
-quantities return a quantity.::
+unitSI treats both scalars and arrays as dimensionless for unit checking
+and make all operations involving quantities return a quantity.::
 
     >>> 1 + 1*second   # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
diff --git a/docs_sphinx/unitSI.rst b/docs_sphinx/unitSI.rst
index ed23dae..4754206 100644
--- a/docs_sphinx/unitSI.rst
+++ b/docs_sphinx/unitSI.rst
@@ -23,8 +23,3 @@ Submodules
 
 Module contents
 ---------------
-
-.. automodule:: unitSI
-   :members:
-   :undoc-members:
-   :show-inheritance:
diff --git a/docs_sphinx/user/units.rst b/docs_sphinx/user/units.rst
index 3675585..660431e 100644
--- a/docs_sphinx/user/units.rst
+++ b/docs_sphinx/user/units.rst
@@ -5,10 +5,10 @@ Physical units
     :local:
     :depth: 1
 
-Brian includes a system for physical units. The base units are defined by their
+unitSI is a system for physical units. The base units are defined by their
 standard SI unit names: ``amp``/``ampere``, ``kilogram``/``kilogramme``,
 ``second``, ``metre``/``meter``, ``mole``/``mol``, ``kelvin``, and ``candela``.
-In addition to these base units, Brian defines a set of derived units:
+In addition to these base units, unitSI defines a set of derived units:
 ``coulomb``, ``farad``, ``gram``/``gramme``, ``hertz``, ``joule``, ``liter``/
 ``litre``, ``molar``, ``pascal``, ``ohm``,  ``siemens``, ``volt``, ``watt``,
 together with prefixed versions (e.g. ``msiemens = 0.001*siemens``) using the
@@ -34,7 +34,7 @@ with its physical unit::
     >>> print(rates)
     [ 10.  20.  30.] Hz
 
-Brian will check the consistency of operations on units and raise an error for
+unitSI will check the consistency of operations on units and raise an error for
 dimensionality mismatches::
 
     >>> tau += 1  # ms? second?  # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
@@ -46,7 +46,7 @@ dimensionality mismatches::
     ...
     DimensionMismatchError: Cannot calculate 3. kg + 3. A, units do not match (units are kilogram and amp).
 
-Most Brian functions will also complain about non-specified or incorrect units::
+In Brian functions will also complain about non-specified or incorrect units::
 
     >>> G = NeuronGroup(10, 'dv/dt = -v/tau: volt', dt=0.5)   # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
@@ -86,8 +86,8 @@ analysis functions that do not correctly work with units)
 
 Temperatures
 ------------
-Brian only supports temperatures defined in °K, using the provided ``kelvin``
-unit object. Other conventions such as °C, or °F are not compatible with Brian's
+unitSI only supports temperatures defined in °K, using the provided ``kelvin``
+unit object. Other conventions such as °C, or °F are not compatible with unitSI
 unit system, because they cannot be expressed as a multiplicative scaling of the
 SI base unit kelvin (their zero point is different). However, in biological
 experiments and modeling, temperatures are typically reported in °C. How to use
@@ -105,15 +105,15 @@ absolute temperatures
     Equations such as the `Goldman–Hodgkin–Katz voltage equation <https://en.wikipedia.org/wiki/Goldman_equation>`_
     have a factor that depends on the absolute temperature measured in Kelvin.
     To get this temperature from a temperature reported in °C, you can use the
-    ``zero_celsius`` constant from the `brian2.units.constants` package (see
+    ``zero_celsius`` constant from the `unitSI.constants` package (see
     below)::
 
-        from brian2.units.constants import zero_celsius
+        from  unitSI.constants import zero_celsius
 
         celsius_temp = 27
         abs_temp = celsius_temp*kelvin + zero_celsius
 
-.. note:: Earlier versions of Brian had a ``celsius`` unit which was in fact
+.. note:: Earlier versions of unitSI had a ``celsius`` unit which was in fact
           identical to ``kelvin``. While this gave the correct results for
           temperature differences, it did not correctly work for absolute
           temperatures. To avoid confusion and possible misinterpretation,
@@ -123,12 +123,12 @@ absolute temperatures
 
 Constants
 ---------
-The `brian2.units.constants` package provides a range of physical constants that
-can be useful for detailed biological models. Brian provides the following
+The `unitSI.constants` package provides a range of physical constants that
+can be useful for detailed biological models. UnitSI provides the following
 constants:
 
 ==================== ================== ======================= ==================================================================
-Constant             Symbol(s)          Brian name              Value
+Constant             Symbol(s)          unitSI name              Value
 ==================== ================== ======================= ==================================================================
 Avogadro constant    :math:`N_A, L`     ``avogadro_constant``   :math:`6.022140857\times 10^{23}\,\mathrm{mol}^{-1}`
 Boltzmann constant   :math:`k`          ``boltzmann_constant``  :math:`1.38064852\times 10^{-23}\,\mathrm{J}\,\mathrm{K}^{-1}`
@@ -143,14 +143,14 @@ Molar mass constant  :math:`M_u`        ``molar_mass_constant`` :math:`1\times 1
 ==================== ================== ======================= ==================================================================
 
 Note that these constants are not imported by default, you will have to
-explicitly import them from `brian2.units.constants`. During the import, you
+explicitly import them from `unitSI.constants`. During the import, you
 can also give them shorter names using Python's ``from ... import ... as ...``
 syntax. For example, to calculate the :math:`\frac{RT}{F}` factor that appears
 in the `Goldman–Hodgkin–Katz voltage equation <https://en.wikipedia.org/wiki/Goldman_equation>`_
 you can use::
 
-    from brian2 import *
-    from brian2.units.constants import zero_celsius, gas_constant as R, faraday_constant as F
+    from unitSI import *
+    from unitSI.constants import zero_celsius, gas_constant as R, faraday_constant as F
 
     celsius_temp = 27
     T = celsius_temp*kelvin + zero_celsius
@@ -163,7 +163,7 @@ you can use::
 
 Importing units
 ---------------
-Brian generates standard names for units, combining the unit name (e.g.
+unitSI generates standard names for units, combining the unit name (e.g.
 "siemens") with a prefixes (e.g. "m"), and also generates squared and cubed
 versions by appending a number. For example, the units "msiemens", "siemens2",
 "usiemens3" are all predefined. You can import these units from the package
@@ -171,8 +171,7 @@ versions by appending a number. For example, the units "msiemens", "siemens2",
 ``from brian2.units.allunits import *`` will result in everything from
 ``Ylumen3`` (cubed yotta lumen) to ``ymol`` (yocto mole) being imported.
 
-A better choice is normally to do ``from brian2.units import *`` or import
-everything ``from brian2 import *`` which only imports the units mentioned in
+A better choice is normally to do ``from unitSI import *`` which only imports the units mentioned in
 the introductory paragraph (base units, derived units, and some standard
 abbreviations).
 
diff --git a/pyproject.toml b/pyproject.toml
index e823fff..a9f25df 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -28,9 +28,9 @@ test = ['pytest', 'pytest-xdist>=1.22.3']
 docs = ['sphinx>=7', 'ipython>=5', 'sphinx-tabs']
 
 [project.urls]
-Documentation ='https://brian2units.readthedocs.io/en/latest/'
-Source = 'https://github.com/brian-team/brian2units'
-Tracker = 'https://github.com/brian-team/brian2units/issues'
+Documentation ='https://unitSI.readthedocs.io/en/latest/'
+Source = 'https://github.com/brian-team/unitSI'
+Tracker = 'https://github.com/brian-team/unitSI/issues'
 
 [build-system]
 requires = [
diff --git a/unitSI/__init__.py b/unitSI/__init__.py
index b5b2297..cee7d46 100644
--- a/unitSI/__init__.py
+++ b/unitSI/__init__.py
@@ -183,9 +183,6 @@
     Gwatt,
     Twatt,
 )
-from .unitsafefunctions import *
-from .unitsafefunctions import __all__ as unitsafefunctions_all
-
 from .fundamentalunits import *
 from .fundamentalunits import __all__ as fundamentalunits_all
 
@@ -371,6 +368,5 @@
     "Gwatt",
     "Twatt",
 ]
-__all__.extend(unitsafefunctions_all)
 __all__.extend(fundamentalunits_all)
 __all__.extend(stdunits_all)
diff --git a/unitSI/tests/test_units.py b/unitSI/tests/test_units.py
index e5aad3a..348df33 100644
--- a/unitSI/tests/test_units.py
+++ b/unitSI/tests/test_units.py
@@ -6,7 +6,6 @@
 import pytest
 from numpy.testing import assert_equal
 
-from unitSI.unitsafefunctions import arange, linspace 
 from unitSI.allunits import *
 from unitSI.fundamentalunits import (
     DIMENSIONLESS,
@@ -795,258 +794,240 @@ def illegal_pow(q2):
 
 
 
-def test_unit_discarding_functions():
-    """
-    Test functions that discard units.
-    """
-    from unitSI.unitsafefunctions import ones_like, zeros_like
-
-    values = [3 * mV, np.array([1, 2]) * mV, np.arange(12).reshape(3, 4) * mV]
-    for value in values:
-        assert_equal(np.sign(value), np.sign(np.asarray(value)))
-        assert_equal(zeros_like(value), np.zeros_like(np.asarray(value)))
-        assert_equal(ones_like(value), np.ones_like(np.asarray(value)))
-        # Calling non-zero on a 0d array is deprecated, don't test it:
-        if value.ndim > 0:
-            assert_equal(np.nonzero(value), np.nonzero(np.asarray(value)))
-
-
-
-def test_unitsafe_functions():
-    """
-    Test the unitsafe functions wrapping their numpy counterparts.
-    """
-    from unitSI.unitsafefunctions import (
-        arccos,
-        arccosh,
-        arcsin,
-        arcsinh,
-        arctan,
-        arctanh,
-        cos,
-        cosh,
-        exp,
-        log,
-        sin,
-        sinh,
-        tan,
-        tanh,
-    )
-
-    # All functions with their numpy counterparts
-    funcs = [
-        (sin, np.sin),
-        (sinh, np.sinh),
-        (arcsin, np.arcsin),
-        (arcsinh, np.arcsinh),
-        (cos, np.cos),
-        (cosh, np.cosh),
-        (arccos, np.arccos),
-        (arccosh, np.arccosh),
-        (tan, np.tan),
-        (tanh, np.tanh),
-        (arctan, np.arctan),
-        (arctanh, np.arctanh),
-        (log, np.log),
-        (exp, np.exp),
-    ]
-
-    unitless_values = [
-        3 * mV / mV,
-        np.array([1, 2]) * mV / mV,
-        np.ones((3, 3)) * mV / mV,
-    ]
-    numpy_values = [3, np.array([1, 2]), np.ones((3, 3))]
-    unit_values = [3 * mV, np.array([1, 2]) * mV, np.ones((3, 3)) * mV]
-
-    for func, np_func in funcs:
-        # make sure these functions raise errors when run on values with dimensions
-        for val in unit_values:
-            with pytest.raises(DimensionMismatchError):
-                func(val)
-
-        # make sure the functions are equivalent to their numpy counterparts
-        # when run on unitless values while ignoring warnings about invalid
-        # values or divisions by zero
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-
-            for val in unitless_values:
-                assert_equal(func(val), np_func(val))
-
-            for val in numpy_values:
-                assert_equal(func(val), np_func(val))
-
-
+# def test_unit_discarding_functions():
+#     """
+#     Test functions that discard units.
+#     """
+#     values = [3 * mV, np.array([1, 2]) * mV, np.arange(12).reshape(3, 4) * mV]
+#     for value in values:
+#         assert_equal(np.sign(value), np.sign(np.asarray(value)))
+#         assert_equal(zeros_like(value), np.zeros_like(np.asarray(value)))
+#         assert_equal(ones_like(value), np.ones_like(np.asarray(value)))
+#         # Calling non-zero on a 0d array is deprecated, don't test it:
+#         if value.ndim > 0:
+#             assert_equal(np.nonzero(value), np.nonzero(np.asarray(value)))
 
-def test_special_case_numpy_functions():
-    """
-    Test a couple of functions/methods that need special treatment.
-    """
-    from unitSI.unitsafefunctions import diagonal, dot, ravel, trace, where
 
-    quadratic_matrix = np.reshape(np.arange(9), (3, 3)) * mV
 
-    # Temporarily suppress warnings related to the matplotlib 1.3 bug
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        # Check that function and method do the same thing
-        assert_equal(ravel(quadratic_matrix), quadratic_matrix.ravel())
-        # Check that function gives the same result as on unitless arrays
-        assert_equal(
-            np.asarray(ravel(quadratic_matrix)), ravel(np.asarray(quadratic_matrix))
-        )
-        # Check that the function gives the same results as the original numpy
-        # function
-        assert_equal(
-            np.ravel(np.asarray(quadratic_matrix)), ravel(np.asarray(quadratic_matrix))
-        )
-
-    # Do the same checks for diagonal, trace and dot
-    assert_equal(diagonal(quadratic_matrix), quadratic_matrix.diagonal())
-    assert_equal(
-        np.asarray(diagonal(quadratic_matrix)), diagonal(np.asarray(quadratic_matrix))
-    )
-    assert_equal(
-        np.diagonal(np.asarray(quadratic_matrix)),
-        diagonal(np.asarray(quadratic_matrix)),
-    )
-
-    assert_equal(trace(quadratic_matrix), quadratic_matrix.trace())
-    assert_equal(
-        np.asarray(trace(quadratic_matrix)), trace(np.asarray(quadratic_matrix))
-    )
-    assert_equal(
-        np.trace(np.asarray(quadratic_matrix)), trace(np.asarray(quadratic_matrix))
-    )
+# def test_unitsafe_functions():
+#     """
+#     Test the unitsafe functions wrapping their numpy counterparts.
+#     """
 
-    assert_equal(
-        dot(quadratic_matrix, quadratic_matrix), quadratic_matrix.dot(quadratic_matrix)
-    )
-    assert_equal(
-        np.asarray(dot(quadratic_matrix, quadratic_matrix)),
-        dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
-    )
-    assert_equal(
-        np.dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
-        dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
-    )
+#     # All functions with their numpy counterparts
+#     funcs = [
+#         (sin, np.sin),
+#         (sinh, np.sinh),
+#         (arcsin, np.arcsin),
+#         (arcsinh, np.arcsinh),
+#         (cos, np.cos),
+#         (cosh, np.cosh),
+#         (arccos, np.arccos),
+#         (arccosh, np.arccosh),
+#         (tan, np.tan),
+#         (tanh, np.tanh),
+#         (arctan, np.arctan),
+#         (arctanh, np.arctanh),
+#         (log, np.log),
+#         (exp, np.exp),
+#     ]
+
+#     unitless_values = [
+#         3 * mV / mV,
+#         np.array([1, 2]) * mV / mV,
+#         np.ones((3, 3)) * mV / mV,
+#     ]
+#     numpy_values = [3, np.array([1, 2]), np.ones((3, 3))]
+#     unit_values = [3 * mV, np.array([1, 2]) * mV, np.ones((3, 3)) * mV]
+
+#     for func, np_func in funcs:
+#         # make sure these functions raise errors when run on values with dimensions
+#         for val in unit_values:
+#             with pytest.raises(DimensionMismatchError):
+#                 func(val)
+
+#         # make sure the functions are equivalent to their numpy counterparts
+#         # when run on unitless values while ignoring warnings about invalid
+#         # values or divisions by zero
+#         with warnings.catch_warnings():
+#             warnings.simplefilter("ignore")
+
+#             for val in unitless_values:
+#                 assert_equal(func(val), np_func(val))
+
+#             for val in numpy_values:
+#                 assert_equal(func(val), np_func(val))
+
+
+
+# def test_special_case_numpy_functions():
+#     """
+#     Test a couple of functions/methods that need special treatment.
+#     """
+#     from unitSI.unitsafefunctions import diagonal, dot, ravel, trace, where
+
+#     quadratic_matrix = np.reshape(np.arange(9), (3, 3)) * mV
+
+#     # Temporarily suppress warnings related to the matplotlib 1.3 bug
+#     with warnings.catch_warnings():
+#         warnings.simplefilter("ignore")
+#         # Check that function and method do the same thing
+#         assert_equal(ravel(quadratic_matrix), quadratic_matrix.ravel())
+#         # Check that function gives the same result as on unitless arrays
+#         assert_equal(
+#             np.asarray(ravel(quadratic_matrix)), ravel(np.asarray(quadratic_matrix))
+#         )
+#         # Check that the function gives the same results as the original numpy
+#         # function
+#         assert_equal(
+#             np.ravel(np.asarray(quadratic_matrix)), ravel(np.asarray(quadratic_matrix))
+#         )
+
+#     # Do the same checks for diagonal, trace and dot
+#     assert_equal(diagonal(quadratic_matrix), quadratic_matrix.diagonal())
+#     assert_equal(
+#         np.asarray(diagonal(quadratic_matrix)), diagonal(np.asarray(quadratic_matrix))
+#     )
+#     assert_equal(
+#         np.diagonal(np.asarray(quadratic_matrix)),
+#         diagonal(np.asarray(quadratic_matrix)),
+#     )
 
-    assert_equal(
-        np.asarray(quadratic_matrix.prod()), np.asarray(quadratic_matrix).prod()
-    )
-    assert_equal(
-        np.asarray(quadratic_matrix.prod(axis=0)),
-        np.asarray(quadratic_matrix).prod(axis=0),
-    )
+#     assert_equal(trace(quadratic_matrix), quadratic_matrix.trace())
+#     assert_equal(
+#         np.asarray(trace(quadratic_matrix)), trace(np.asarray(quadratic_matrix))
+#     )
+#     assert_equal(
+#         np.trace(np.asarray(quadratic_matrix)), trace(np.asarray(quadratic_matrix))
+#     )
 
-    # Check for correct units
-    if use_matplotlib_units_fix:
-        assert have_same_dimensions(1, ravel(quadratic_matrix))
-    else:
-        assert have_same_dimensions(quadratic_matrix, ravel(quadratic_matrix))
-    assert have_same_dimensions(quadratic_matrix, trace(quadratic_matrix))
-    assert have_same_dimensions(quadratic_matrix, diagonal(quadratic_matrix))
-    assert have_same_dimensions(
-        quadratic_matrix[0] ** 2, dot(quadratic_matrix, quadratic_matrix)
-    )
-    assert have_same_dimensions(
-        quadratic_matrix.prod(axis=0), quadratic_matrix[0] ** quadratic_matrix.shape[0]
-    )
+#     assert_equal(
+#         dot(quadratic_matrix, quadratic_matrix), quadratic_matrix.dot(quadratic_matrix)
+#     )
+#     assert_equal(
+#         np.asarray(dot(quadratic_matrix, quadratic_matrix)),
+#         dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
+#     )
+#     assert_equal(
+#         np.dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
+#         dot(np.asarray(quadratic_matrix), np.asarray(quadratic_matrix)),
+#     )
 
-    # check the where function
-    # pure numpy array
-    cond = [True, False, False]
-    ar1 = np.array([1, 2, 3])
-    ar2 = np.array([4, 5, 6])
-    assert_equal(np.where(cond), where(cond))
-    assert_equal(np.where(cond, ar1, ar2), where(cond, ar1, ar2))
-
-    # dimensionless quantity
-    assert_equal(
-        np.where(cond, ar1, ar2), np.asarray(where(cond, ar1 * mV / mV, ar2 * mV / mV))
-    )
+#     assert_equal(
+#         np.asarray(quadratic_matrix.prod()), np.asarray(quadratic_matrix).prod()
+#     )
+#     assert_equal(
+#         np.asarray(quadratic_matrix.prod(axis=0)),
+#         np.asarray(quadratic_matrix).prod(axis=0),
+#     )
 
-    # quantity with dimensions
-    ar1 = ar1 * mV
-    ar2 = ar2 * mV
-    assert_equal(
-        np.where(cond, np.asarray(ar1), np.asarray(ar2)),
-        np.asarray(where(cond, ar1, ar2)),
-    )
+#     # Check for correct units
+#     if use_matplotlib_units_fix:
+#         assert have_same_dimensions(1, ravel(quadratic_matrix))
+#     else:
+#         assert have_same_dimensions(quadratic_matrix, ravel(quadratic_matrix))
+#     assert have_same_dimensions(quadratic_matrix, trace(quadratic_matrix))
+#     assert have_same_dimensions(quadratic_matrix, diagonal(quadratic_matrix))
+#     assert have_same_dimensions(
+#         quadratic_matrix[0] ** 2, dot(quadratic_matrix, quadratic_matrix)
+#     )
+#     assert have_same_dimensions(
+#         quadratic_matrix.prod(axis=0), quadratic_matrix[0] ** quadratic_matrix.shape[0]
+#     )
 
-    # Check some error cases
-    with pytest.raises(ValueError):
-        where(cond, ar1)
-    with pytest.raises(TypeError):
-        where(cond, ar1, ar1, ar2)
-    with pytest.raises(DimensionMismatchError):
-        where(cond, ar1, ar1 / ms)
+#     # check the where function
+#     # pure numpy array
+#     cond = [True, False, False]
+#     ar1 = np.array([1, 2, 3])
+#     ar2 = np.array([4, 5, 6])
+#     assert_equal(np.where(cond), where(cond))
+#     assert_equal(np.where(cond, ar1, ar2), where(cond, ar1, ar2))
+
+#     # dimensionless quantity
+#     assert_equal(
+#         np.where(cond, ar1, ar2), np.asarray(where(cond, ar1 * mV / mV, ar2 * mV / mV))
+#     )
 
-    # Check setasflat (for numpy < 1.7)
-    if hasattr(Quantity, "setasflat"):
-        a = np.arange(10) * mV
-        b = np.ones(10).reshape(5, 2) * volt
-        c = np.ones(10).reshape(5, 2) * second
-        with pytest.raises(DimensionMismatchError):
-            a.setasflat(c)
-        a.setasflat(b)
-        assert_equal(a.flatten(), b.flatten())
+#     # quantity with dimensions
+#     ar1 = ar1 * mV
+#     ar2 = ar2 * mV
+#     assert_equal(
+#         np.where(cond, np.asarray(ar1), np.asarray(ar2)),
+#         np.asarray(where(cond, ar1, ar2)),
+#     )
 
-    # Check cumprod
-    a = np.arange(1, 10) * mV / mV
-    assert_equal(a.cumprod(), np.asarray(a).cumprod())
-    with pytest.raises(TypeError):
-        (np.arange(1, 5) * mV).cumprod()
+#     # Check some error cases
+#     with pytest.raises(ValueError):
+#         where(cond, ar1)
+#     with pytest.raises(TypeError):
+#         where(cond, ar1, ar1, ar2)
+#     with pytest.raises(DimensionMismatchError):
+#         where(cond, ar1, ar1 / ms)
+
+#     # Check setasflat (for numpy < 1.7)
+#     if hasattr(Quantity, "setasflat"):
+#         a = np.arange(10) * mV
+#         b = np.ones(10).reshape(5, 2) * volt
+#         c = np.ones(10).reshape(5, 2) * second
+#         with pytest.raises(DimensionMismatchError):
+#             a.setasflat(c)
+#         a.setasflat(b)
+#         assert_equal(a.flatten(), b.flatten())
+
+#     # Check cumprod
+#     a = np.arange(1, 10) * mV / mV
+#     assert_equal(a.cumprod(), np.asarray(a).cumprod())
+#     with pytest.raises(TypeError):
+#         (np.arange(1, 5) * mV).cumprod()
 
 
 # Functions that should not change units
 
-def test_numpy_functions_same_dimensions():
-    values = [np.array([1, 2]), np.ones((3, 3))]
-    units = [volt, second, siemens, mV, kHz]
-
-    from unitSI.unitsafefunctions import ptp
-
-    # numpy functions
-    keep_dim_funcs = [
-        np.abs,
-        np.cumsum,
-        np.max,
-        np.mean,
-        np.min,
-        np.negative,
-        ptp,
-        np.round,
-        np.squeeze,
-        np.std,
-        np.sum,
-        np.transpose,
-    ]
-
-    for value, unit in itertools.product(values, units):
-        q_ar = value * unit
-        for func in keep_dim_funcs:
-            test_ar = func(q_ar)
-            if not get_dimensions(test_ar) is q_ar.dim:
-                raise AssertionError(
-                    f"'{func.__name__}' failed on {q_ar!r} -- dim was "
-                    f"{q_ar.dim}, is now {get_dimensions(test_ar)}."
-                )
-
-                # Python builtins should work on one-dimensional arrays
-                value = np.arange(5)
-                builtins = [abs, max, min, sum]
-                for unit in units:
-                    q_ar = value * unit
-                for func in builtins:
-                    test_ar = func(q_ar)
-                if not get_dimensions(test_ar) is q_ar.dim:
-                    raise AssertionError(
-                        f"'{func.__name__}' failed on {q_ar!r} -- dim "
-                        f"was {q_ar.dim}, is now "
-                        f"{get_dimensions(test_ar)}"
-                    )
+# def test_numpy_functions_same_dimensions():
+#     values = [np.array([1, 2]), np.ones((3, 3))]
+#     units = [volt, second, siemens, mV, kHz]
+
+#     from unitSI.unitsafefunctions import ptp
+
+#     # numpy functions
+#     keep_dim_funcs = [
+#         np.abs,
+#         np.cumsum,
+#         np.max,
+#         np.mean,
+#         np.min,
+#         np.negative,
+#         ptp,
+#         np.round,
+#         np.squeeze,
+#         np.std,
+#         np.sum,
+#         np.transpose,
+#     ]
+
+#     for value, unit in itertools.product(values, units):
+#         q_ar = value * unit
+#         for func in keep_dim_funcs:
+#             test_ar = func(q_ar)
+#             if not get_dimensions(test_ar) is q_ar.dim:
+#                 raise AssertionError(
+#                     f"'{func.__name__}' failed on {q_ar!r} -- dim was "
+#                     f"{q_ar.dim}, is now {get_dimensions(test_ar)}."
+#                 )
+
+#                 # Python builtins should work on one-dimensional arrays
+#                 value = np.arange(5)
+#                 builtins = [abs, max, min, sum]
+#                 for unit in units:
+#                     q_ar = value * unit
+#                 for func in builtins:
+#                     test_ar = func(q_ar)
+#                 if not get_dimensions(test_ar) is q_ar.dim:
+#                     raise AssertionError(
+#                         f"'{func.__name__}' failed on {q_ar!r} -- dim "
+#                         f"was {q_ar.dim}, is now "
+#                         f"{get_dimensions(test_ar)}"
+#                     )
 
 
 
@@ -1541,7 +1522,7 @@ def test_constants():
     test_construction()
     test_get_dimensions()
     test_display()
-    test_scale()
+    # test_scale()
     test_power()
     test_pickling()
     test_str_repr()
@@ -1552,10 +1533,10 @@ def test_constants():
     test_unary_operations()
     test_binary_operations()
     test_inplace_operations()
-    test_unit_discarding_functions()
-    test_unitsafe_functions()
-    test_special_case_numpy_functions()
-    test_numpy_functions_same_dimensions()
+    # test_unit_discarding_functions()
+    # test_unitsafe_functions()
+    # test_special_case_numpy_functions()
+    # test_numpy_functions_same_dimensions()
     test_numpy_functions_indices()
     test_numpy_functions_dimensionless()
     test_numpy_functions_change_dimensions()
diff --git a/unitSI/unitsafefunctions.py b/unitSI/unitsafefunctions.py
deleted file mode 100644
index 6548e43..0000000
--- a/unitSI/unitsafefunctions.py
+++ /dev/null
@@ -1,282 +0,0 @@
-"""
-Unit-aware replacements for numpy functions.
-"""
-
-from functools import wraps
-
-import numpy as np
-
-from .fundamentalunits import (
-    DIMENSIONLESS,
-    Quantity,
-    check_units,
-    fail_for_dimension_mismatch,
-    is_dimensionless,
-    wrap_function_dimensionless,
-    wrap_function_keep_dimensions,
-    wrap_function_remove_dimensions,
-)
-
-__all__ = [
-    "log",
-    "log10",
-    "exp",
-    "expm1",
-    "log1p",
-    "exprel",
-    "sin",
-    "cos",
-    "tan",
-    "arcsin",
-    "arccos",
-    "arctan",
-    "sinh",
-    "cosh",
-    "tanh",
-    "arcsinh",
-    "arccosh",
-    "arctanh",
-    "diagonal",
-    "ravel",
-    "trace",
-    "dot",
-    "where",
-    "ones_like",
-    "zeros_like",
-    "arange",
-    "linspace",
-    "ptp",
-]
-
-
-def where(condition, *args, **kwds):  # pylint: disable=C0111
-    if len(args) == 0:
-        # nothing to do
-        return np.where(condition, *args, **kwds)
-    elif len(args) == 2:
-        # check that x and y have the same dimensions
-        fail_for_dimension_mismatch(
-            args[0], args[1], "x and y need to have the same dimensions"
-        )
-
-        if is_dimensionless(args[0]):
-            return np.where(condition, *args, **kwds)
-        else:
-            # as both arguments have the same unit, just use the first one's
-            dimensionless_args = [np.asarray(arg) for arg in args]
-            return Quantity.with_dimensions(
-                np.where(condition, *dimensionless_args), args[0].dimensions
-            )
-    else:
-        # illegal number of arguments, let numpy take care of this
-        return np.where(condition, *args, **kwds)
-
-
-where.__doc__ = np.where.__doc__
-where._do_not_run_doctests = True
-
-# Functions that work on dimensionless quantities only
-sin = wrap_function_dimensionless(np.sin)
-sinh = wrap_function_dimensionless(np.sinh)
-arcsin = wrap_function_dimensionless(np.arcsin)
-arcsinh = wrap_function_dimensionless(np.arcsinh)
-cos = wrap_function_dimensionless(np.cos)
-cosh = wrap_function_dimensionless(np.cosh)
-arccos = wrap_function_dimensionless(np.arccos)
-arccosh = wrap_function_dimensionless(np.arccosh)
-tan = wrap_function_dimensionless(np.tan)
-tanh = wrap_function_dimensionless(np.tanh)
-arctan = wrap_function_dimensionless(np.arctan)
-arctanh = wrap_function_dimensionless(np.arctanh)
-
-log = wrap_function_dimensionless(np.log)
-log10 = wrap_function_dimensionless(np.log10)
-exp = wrap_function_dimensionless(np.exp)
-expm1 = wrap_function_dimensionless(np.expm1)
-log1p = wrap_function_dimensionless(np.log1p)
-
-ptp = wrap_function_keep_dimensions(np.ptp)
-
-
-@check_units(x=1, result=1)
-def exprel(x):
-    x = np.asarray(x)
-    if issubclass(x.dtype.type, np.integer):
-        result = np.empty_like(x, dtype=np.float64)
-    else:
-        result = np.empty_like(x)
-    # Following the implementation of exprel from scipy.special
-    if x.shape == ():
-        if np.abs(x) < 1e-16:
-            return 1.0
-        elif x > 717:
-            return np.inf
-        else:
-            return np.expm1(x) / x
-    else:
-        small = np.abs(x) < 1e-16
-        big = x > 717
-        in_between = np.logical_not(small | big)
-        result[small] = 1.0
-        result[big] = np.inf
-        result[in_between] = np.expm1(x[in_between]) / x[in_between]
-        return result
-
-
-ones_like = wrap_function_remove_dimensions(np.ones_like)
-zeros_like = wrap_function_remove_dimensions(np.zeros_like)
-
-
-def wrap_function_to_method(func):
-    """
-    Wraps a function so that it calls the corresponding method on the
-    Quantities object (if called with a Quantities object as the first
-    argument). All other arguments are left untouched.
-    """
-
-    @wraps(func)
-    def f(x, *args, **kwds):  # pylint: disable=C0111
-        if isinstance(x, Quantity):
-            return getattr(x, func.__name__)(*args, **kwds)
-        else:
-            # no need to wrap anything
-            return func(x, *args, **kwds)
-
-    f.__doc__ = func.__doc__
-    f.__name__ = func.__name__
-    f._do_not_run_doctests = True
-    return f
-
-
-@wraps(np.arange)
-def arange(*args, **kwargs):
-    # arange has a bit of a complicated argument structure unfortunately
-    # we leave the actual checking of the number of arguments to numpy, though
-
-    # default values
-    start = kwargs.pop("start", 0)
-    step = kwargs.pop("step", 1)
-    stop = kwargs.pop("stop", None)
-    if len(args) == 1:
-        if stop is not None:
-            raise TypeError("Duplicate definition of 'stop'")
-        stop = args[0]
-    elif len(args) == 2:
-        if start != 0:
-            raise TypeError("Duplicate definition of 'start'")
-        if stop is not None:
-            raise TypeError("Duplicate definition of 'stop'")
-        start, stop = args
-    elif len(args) == 3:
-        if start != 0:
-            raise TypeError("Duplicate definition of 'start'")
-        if stop is not None:
-            raise TypeError("Duplicate definition of 'stop'")
-        if step != 1:
-            raise TypeError("Duplicate definition of 'step'")
-        start, stop, step = args
-    elif len(args) > 3:
-        raise TypeError("Need between 1 and 3 non-keyword arguments")
-    if stop is None:
-        raise TypeError("Missing stop argument.")
-    fail_for_dimension_mismatch(
-        start,
-        stop,
-        error_message=(
-            "Start value {start} and stop value {stop} have to have the same units."
-        ),
-        start=start,
-        stop=stop,
-    )
-    fail_for_dimension_mismatch(
-        stop,
-        step,
-        error_message=(
-            "Stop value {stop} and step value {step} have to have the same units."
-        ),
-        stop=stop,
-        step=step,
-    )
-    dim = getattr(stop, "dim", DIMENSIONLESS)
-    # start is a position-only argument in numpy 2.0
-    # https://numpy.org/devdocs/release/2.0.0-notes.html#arange-s-start-argument-is-positional-only
-    # TODO: check whether this is still the case in the final release
-    if start == 0:
-        return Quantity(
-            np.arange(
-                stop=np.asarray(stop),
-                step=np.asarray(step),
-                **kwargs,
-            ),
-            dim=dim,
-        )
-    else:
-        return Quantity(
-            np.arange(
-                np.asarray(start),
-                stop=np.asarray(stop),
-                step=np.asarray(step),
-                **kwargs,
-            ),
-            dim=dim,
-        )
-
-
-arange._do_not_run_doctests = True
-
-
-@wraps(np.linspace)
-def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None):
-    fail_for_dimension_mismatch(
-        start,
-        stop,
-        error_message=(
-            "Start value {start} and stop value {stop} have to have the same units."
-        ),
-        start=start,
-        stop=stop,
-    )
-    dim = getattr(start, "dim", DIMENSIONLESS)
-    result = np.linspace(
-        np.asarray(start),
-        np.asarray(stop),
-        num=num,
-        endpoint=endpoint,
-        retstep=retstep,
-        dtype=dtype,
-    )
-    return Quantity(result, dim=dim)
-
-
-linspace._do_not_run_doctests = True
-
-# these functions discard subclass info -- maybe a bug in numpy?
-ravel = wrap_function_to_method(np.ravel)
-diagonal = wrap_function_to_method(np.diagonal)
-trace = wrap_function_to_method(np.trace)
-dot = wrap_function_to_method(np.dot)
-
-# This is a very minor detail: setting the __module__ attribute allows the
-# automatic reference doc generation mechanism to attribute the functions to
-# this module. Maybe also helpful for IDEs and other code introspection tools.
-sin.__module__ = __name__
-sinh.__module__ = __name__
-arcsin.__module__ = __name__
-arcsinh.__module__ = __name__
-cos.__module__ = __name__
-cosh.__module__ = __name__
-arccos.__module__ = __name__
-arccosh.__module__ = __name__
-tan.__module__ = __name__
-tanh.__module__ = __name__
-arctan.__module__ = __name__
-arctanh.__module__ = __name__
-
-log.__module__ = __name__
-exp.__module__ = __name__
-ravel.__module__ = __name__
-diagonal.__module__ = __name__
-trace.__module__ = __name__
-dot.__module__ = __name__
-arange.__module__ = __name__
-linspace.__module__ = __name__