From a5cf4a090b3c4d4063f723ab7409113749e377d1 Mon Sep 17 00:00:00 2001
From: Clonkk <sidger@zoho.com>
Date: Wed, 3 Feb 2021 12:06:41 +0100
Subject: [PATCH] fftshift in its own file

---
 docs/fftw3.html          |  52 +-------
 docs/fftw3.idx           |   3 -
 docs/fftw3/fftshift.html | 254 +++++++++++++++++++++++++++++++++++++++
 docs/fftw3/fftshift.idx  |  10 ++
 docs/fftw3/guru.html     |   2 +-
 docs/fftw3/libutils.html |   2 +-
 docs/fftw3/wisdom.html   |   2 +-
 docs/theindex.html       |  34 +++++-
 src/fftw3.nim            |  92 +-------------
 src/fftw3/fftshift.nim   | 144 ++++++++++++++++++++++
 10 files changed, 445 insertions(+), 150 deletions(-)
 create mode 100644 docs/fftw3/fftshift.html
 create mode 100644 docs/fftw3/fftshift.idx
 create mode 100644 src/fftw3/fftshift.nim

diff --git a/docs/fftw3.html b/docs/fftw3.html
index 4e1389a..7b25756 100644
--- a/docs/fftw3.html
+++ b/docs/fftw3.html
@@ -157,11 +157,6 @@ <h1 class="title">fftw3</h1>
     title="fftw_execute_dft_c2r(p: fftw_plan; input: Tensor[Complex64];
                      output: Tensor[float64])">fftw_execute_dft_c2r,<wbr>fftw_plan,<wbr>Tensor[Complex64],<wbr>Tensor[float64]</a></li>
 
-  </ul>
-  <ul class="simple nested-toc-section">circshift
-      <li><a class="reference" href="#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D"
-    title="circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]">circshift,<wbr>Tensor[T],<wbr>seq[int]</a></li>
-
   </ul>
   <ul class="simple nested-toc-section">fftw_plan_many_dft_r2c
       <li><a class="reference" href="#fftw_plan_many_dft_r2c%2Ccint%2Cptr.cint%2Ccint%2Cptr.cdouble%2Cptr.cint%2Ccint%2Ccint%2Cptr.Complex64%2Cptr.cint%2Ccint%2Ccint%2Ccuint"
@@ -184,11 +179,6 @@ <h1 class="title">fftw3</h1>
     title="fftw_plan_dft_2d(input: Tensor[Complex64]; output: Tensor[Complex64];
                  sign: cint; flags: cuint = FFTW_MEASURE): fftw_plan">fftw_plan_dft_2d,<wbr>Tensor[Complex64],<wbr>Tensor[Complex64],<wbr>cint,<wbr>cuint</a></li>
 
-  </ul>
-  <ul class="simple nested-toc-section">ifftshift
-      <li><a class="reference" href="#ifftshift%2CTensor%5BT%5D"
-    title="ifftshift[T](t: Tensor[T]): Tensor[T]">ifftshift,<wbr>Tensor[T]</a></li>
-
   </ul>
   <ul class="simple nested-toc-section">fftw_execute_dft
       <li><a class="reference" href="#fftw_execute_dft%2Cfftw_plan%2Cptr.Complex64%2Cptr.Complex64"
@@ -250,11 +240,6 @@ <h1 class="title">fftw3</h1>
     title="fftw_plan_dft_r2c(input: Tensor[float64]; output: Tensor[Complex64];
                   flags: cuint = FFTW_MEASURE): fftw_plan">fftw_plan_dft_r2c,<wbr>Tensor[float64],<wbr>Tensor[Complex64],<wbr>cuint</a></li>
 
-  </ul>
-  <ul class="simple nested-toc-section">fftshift
-      <li><a class="reference" href="#fftshift%2CTensor%5BT%5D"
-    title="fftshift[T](t: Tensor[T]): Tensor[T]">fftshift,<wbr>Tensor[T]</a></li>
-
   </ul>
   <ul class="simple nested-toc-section">fftw_plan_dft_3d
       <li><a class="reference" href="#fftw_plan_dft_3d%2Ccint%2Ccint%2Ccint%2Cptr.Complex64%2Cptr.Complex64%2Ccint%2Ccuint"
@@ -419,7 +404,7 @@ <h1><a class="toc-backref" id="planner-flags" href="#planner-flags">Planner flag
   <div class="section" id="6">
 <h1><a class="toc-backref" href="#6">Imports</a></h1>
 <dl class="item">
-<a class="reference external" href="fftw3/libutils.html">fftw3/libutils</a>, <a class="reference external" href="fftw3/guru.html">fftw3/guru</a>, <a class="reference external" href="fftw3/wisdom.html">fftw3/wisdom</a>
+<a class="reference external" href="fftw3/libutils.html">fftw3/libutils</a>, <a class="reference external" href="fftw3/guru.html">fftw3/guru</a>, <a class="reference external" href="fftw3/wisdom.html">fftw3/wisdom</a>, <a class="reference external" href="fftw3/fftshift.html">fftw3/fftshift</a>
 </dl></div>
 <div class="section" id="10">
 <h1><a class="toc-backref" href="#10">Consts</a></h1>
@@ -526,37 +511,6 @@ <h1><a class="toc-backref" href="#10">Consts</a></h1>
 <div class="section" id="12">
 <h1><a class="toc-backref" href="#12">Procs</a></h1>
 <dl class="item">
-<a id="circshift,Tensor[T],seq[int]"></a>
-<dt><pre><span class="Keyword">proc</span> <a href="#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D"><span class="Identifier">circshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">;</span> <span class="Identifier">shift</span><span class="Other">:</span> <span class="Identifier">seq</span><span class="Other">[</span><span class="Identifier">int</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
-<dd>
-
-Generic Circshift
-
-</dd>
-<a id="fftshift,Tensor[T]"></a>
-<dt><pre><span class="Keyword">proc</span> <a href="#fftshift%2CTensor%5BT%5D"><span class="Identifier">fftshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
-<dd>
-
-Common fftshift function. Use Nim's openMP operator (<tt class="docutils literal"><span class="pre">||</span></tt>) for rank &lt;= 3
-<p><strong class="examples_text">Example:</strong></p>
-<pre class="listing"><span class="Keyword">import</span><span class="Whitespace"> </span><span class="Identifier">arraymancer</span><span class="Whitespace">
-</span><span class="Keyword">let</span><span class="Whitespace"> </span><span class="Identifier">input_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">randomTensor</span><span class="Punctuation">[</span><span class="Identifier">float64</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="FloatNumber">10.0</span><span class="Punctuation">)</span><span class="Whitespace">
-</span><span class="Comment"># output_tensor is the fftshift of input_tensor</span><span class="Whitespace">
-</span><span class="Keyword">var</span><span class="Whitespace"> </span><span class="Identifier">output_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">fftshift</span><span class="Punctuation">(</span><span class="Identifier">input_tensor</span><span class="Punctuation">)</span></pre>
-
-</dd>
-<a id="ifftshift,Tensor[T]"></a>
-<dt><pre><span class="Keyword">proc</span> <a href="#ifftshift%2CTensor%5BT%5D"><span class="Identifier">ifftshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
-<dd>
-
-Common ifftshift function. Use Nim's openMP operator (<tt class="docutils literal"><span class="pre">||</span></tt>) for rank &lt;= 3
-<p><strong class="examples_text">Example:</strong></p>
-<pre class="listing"><span class="Keyword">import</span><span class="Whitespace"> </span><span class="Identifier">arraymancer</span><span class="Whitespace">
-</span><span class="Keyword">let</span><span class="Whitespace"> </span><span class="Identifier">input_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">randomTensor</span><span class="Punctuation">[</span><span class="Identifier">float64</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="FloatNumber">10.0</span><span class="Punctuation">)</span><span class="Whitespace">
-</span><span class="Comment"># output_tensor is the fftshift of input_tensor</span><span class="Whitespace">
-</span><span class="Keyword">var</span><span class="Whitespace"> </span><span class="Identifier">output_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">ifftshift</span><span class="Punctuation">(</span><span class="Identifier">input_tensor</span><span class="Punctuation">)</span></pre>
-
-</dd>
 <a id="fftw_execute,fftw_plan"></a>
 <dt><pre><span class="Keyword">proc</span> <a href="#fftw_execute%2Cfftw_plan"><span class="Identifier">fftw_execute</span></a><span class="Other">(</span><span class="Identifier">p</span><span class="Other">:</span> <a href="fftw3/libutils.html#fftw_plan"><span class="Identifier">fftw_plan</span></a><span class="Other">)</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">cdecl</span><span class="Other">,</span> <span class="Identifier">importc</span><span class="Other">:</span> <span class="StringLit">&quot;fftw_execute&quot;</span><span class="Other">,</span>
                                   <span class="Identifier">dynlib</span><span class="Other">:</span> <span class="Identifier">Fftw3Lib</span></span><span class="Other">.}</span></span></pre></dt>
@@ -1015,7 +969,7 @@ <h1><a class="toc-backref" href="#12">Procs</a></h1>
 <div class="section" id="19">
 <h1><a class="toc-backref" href="#19">Exports</a></h1>
 <dl class="item">
-<a href="fftw3/libutils.html#fftw_plan"><span class="Identifier">fftw_plan</span></a>, <a href="fftw3/libutils.html#fftw_r2r_kind"><span class="Identifier">fftw_r2r_kind</span></a>
+<a href="fftw3/libutils.html#fftw_plan"><span class="Identifier">fftw_plan</span></a>, <a href="fftw3/libutils.html#fftw_r2r_kind"><span class="Identifier">fftw_r2r_kind</span></a>, <a href="fftw3/fftshift.html#fftshift,Tensor[T]"><span class="Identifier">fftshift</span></a>, <a href="fftw3/fftshift.html#ifftshift,Tensor[T]"><span class="Identifier">ifftshift</span></a>, <a href="fftw3/fftshift.html#circshift,Tensor[T],seq[int]"><span class="Identifier">circshift</span></a>, <a href="fftw3/fftshift.html#J,openArray[int]"><span class="Identifier">J</span></a>, <a href="fftw3/fftshift.html#get2DCoord,int,int,int"><span class="Identifier">get2DCoord</span></a>, <a href="fftw3/fftshift.html#get3DCoord,int,int,int,int"><span class="Identifier">get3DCoord</span></a>, <a href="fftw3/fftshift.html#K,openArray[int]"><span class="Identifier">K</span></a>, <a href="fftw3/fftshift.html#get2DCoord,int,Tensor[T]"><span class="Identifier">get2DCoord</span></a>, <a href="fftw3/fftshift.html#get3DCoord,int,Tensor[T]"><span class="Identifier">get3DCoord</span></a>, <a href="fftw3/fftshift.html#I,openArray[int]"><span class="Identifier">I</span></a>
 </dl></div>
 
   </div>
@@ -1025,7 +979,7 @@ <h1><a class="toc-backref" href="#19">Exports</a></h1>
       <div class="twelve-columns footer">
         <span class="nim-sprite"></span>
         <br/>
-        <small style="color: var(--hint);">Made with Nim. Generated: 2020-12-10 16:50:09 UTC</small>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:17 UTC</small>
       </div>
     </div>
   </div>
diff --git a/docs/fftw3.idx b/docs/fftw3.idx
index 8f716af..6210c74 100644
--- a/docs/fftw3.idx
+++ b/docs/fftw3.idx
@@ -14,9 +14,6 @@ FFTW_UNALIGNED	fftw3.html#FFTW_UNALIGNED	fftw3: FFTW_UNALIGNED
 FFTW_CONSERVE_MEMORY	fftw3.html#FFTW_CONSERVE_MEMORY	fftw3: FFTW_CONSERVE_MEMORY	
 FFTW_FORWARD	fftw3.html#FFTW_FORWARD	fftw3: FFTW_FORWARD	
 FFTW_BACKWARD	fftw3.html#FFTW_BACKWARD	fftw3: FFTW_BACKWARD	
-circshift	fftw3.html#circshift,Tensor[T],seq[int]	fftw3: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]	
-fftshift	fftw3.html#fftshift,Tensor[T]	fftw3: fftshift[T](t: Tensor[T]): Tensor[T]	
-ifftshift	fftw3.html#ifftshift,Tensor[T]	fftw3: ifftshift[T](t: Tensor[T]): Tensor[T]	
 fftw_execute	fftw3.html#fftw_execute,fftw_plan	fftw3: fftw_execute(p: fftw_plan)	
 fftw_execute_dft	fftw3.html#fftw_execute_dft,fftw_plan,ptr.Complex64,ptr.Complex64	fftw3: fftw_execute_dft(p: fftw_plan; inptr: ptr Complex64; outptr: ptr Complex64)	
 fftw_execute_dft	fftw3.html#fftw_execute_dft,fftw_plan,Tensor[Complex64],Tensor[Complex64]	fftw3: fftw_execute_dft(p: fftw_plan; input: Tensor[Complex64];\n                 output: Tensor[Complex64])	
diff --git a/docs/fftw3/fftshift.html b/docs/fftw3/fftshift.html
new file mode 100644
index 0000000..90c8107
--- /dev/null
+++ b/docs/fftw3/fftshift.html
@@ -0,0 +1,254 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<!--  This file is generated by Nim. -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+<!-- Favicon -->
+<link rel="shortcut icon" href="data:image/x-icon;base64,AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AAAAAAUAAAAF////AP///wD///8A////AP///wD///8A////AP///wD///8A////AAAAAAIAAABbAAAAlQAAAKIAAACbAAAAmwAAAKIAAACVAAAAWwAAAAL///8A////AP///wD///8A////AAAAABQAAADAAAAAYwAAAA3///8A////AP///wD///8AAAAADQAAAGMAAADAAAAAFP///wD///8A////AP///wAAAACdAAAAOv///wD///8A////AP///wD///8A////AP///wD///8AAAAAOgAAAJ3///8A////AP///wAAAAAnAAAAcP///wAAAAAoAAAASv///wD///8A////AP///wAAAABKAAAAKP///wAAAABwAAAAJ////wD///8AAAAAgQAAABwAAACIAAAAkAAAAJMAAACtAAAAFQAAABUAAACtAAAAkwAAAJAAAACIAAAAHAAAAIH///8A////AAAAAKQAAACrAAAAaP///wD///8AAAAARQAAANIAAADSAAAARf///wD///8AAAAAaAAAAKsAAACk////AAAAADMAAACcAAAAnQAAABj///8A////AP///wAAAAAYAAAAGP///wD///8A////AAAAABgAAACdAAAAnAAAADMAAAB1AAAAwwAAAP8AAADpAAAAsQAAAE4AAAAb////AP///wAAAAAbAAAATgAAALEAAADpAAAA/wAAAMMAAAB1AAAAtwAAAOkAAAD/AAAA/wAAAP8AAADvAAAA3gAAAN4AAADeAAAA3gAAAO8AAAD/AAAA/wAAAP8AAADpAAAAtwAAAGUAAAA/AAAA3wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAADfAAAAPwAAAGX///8A////AAAAAEgAAADtAAAAvwAAAL0AAADGAAAA7wAAAO8AAADGAAAAvQAAAL8AAADtAAAASP///wD///8A////AP///wD///8AAAAAO////wD///8A////AAAAAIcAAACH////AP///wD///8AAAAAO////wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A//8AAP//AAD4HwAA7/cAAN/7AAD//wAAoYUAAJ55AACf+QAAh+EAAAAAAADAAwAA4AcAAP5/AAD//wAA//8AAA=="/>
+<link rel="icon" type="image/png" sizes="32x32" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAA3XAAAN1wFCKJt4AAAAB3RJTUUH4QQQEwksSS9ZWwAAAk1JREFUWMPtll2ITVEUx39nn/O7Y5qR8f05wtCUUr6ZIS++8pEnkZInPImneaCQ5METNdOkeFBKUhMPRIkHKfEuUZSUlGlKPN2TrgfncpvmnntnmlEyq1Z7t89/rf9a6+y99oZxGZf/XeIq61EdtgKXgdXA0xrYAvBjOIF1AI9zvjcC74BSpndrJPkBWDScTF8Aa4E3wDlgHbASaANmVqlcCnwHvgDvgVfAJ+AikAAvgfVZwLnSVZHZaOuKoQi3ZOMi4NkYkpe1p4J7A8BpYAD49hfIy/oqG0+hLomiKP2L5L+1ubn5115S+3OAn4EnwBlgMzCjyt6ZAnQCJ4A7wOs88iRJHvw50HoujuPBoCKwHWiosy8MdfZnAdcHk8dxXFJ3VQbQlCTJvRBCGdRbD4M6uc5glpY3eAihpN5S5w12diSEcCCEcKUO4ljdr15T76ur1FDDLIQQ3qv71EdDOe3Kxj3leRXyk+pxdWnFWod6Wt2bY3de3aSuUHcPBVimHs7mK9WrmeOF6lR1o9qnzskh2ar2qm1qizpfXaPeVGdlmGN5pb09qMxz1Xb1kLqgzn1RyH7JUXW52lr5e/Kqi9qpto7V1atuUzfnARrV7jEib1T76gG2qxdGmXyiekkt1GswPTtek0aBfJp6YySGBfWg2tPQ0FAYgf1stUfdmdcjarbYJEniKIq6gY/Aw+zWHAC+p2labGpqiorFYgGYCEzN7oQdQClN07O1/EfDyGgC0ALMBdYAi4FyK+4H3gLPsxfR1zRNi+NP7nH5J+QntnXe5B5mpfQAAAAASUVORK5CYII=">
+
+<!-- Google fonts -->
+<link href='https://fonts.googleapis.com/css?family=Lato:400,600,900' rel='stylesheet' type='text/css'/>
+<link href='https://fonts.googleapis.com/css?family=Source+Code+Pro:400,500,600' rel='stylesheet' type='text/css'/>
+
+<!-- CSS -->
+<title>fftw3/fftshift</title>
+<link rel="stylesheet" type="text/css" href="../nimdoc.out.css">
+
+<script type="text/javascript" src="../dochack.js"></script>
+
+<script type="text/javascript">
+function main() {
+  var pragmaDots = document.getElementsByClassName("pragmadots");
+  for (var i = 0; i < pragmaDots.length; i++) {
+    pragmaDots[i].onclick = function(event) {
+      // Hide tease
+      event.target.parentNode.style.display = "none";
+      // Show actual
+      event.target.parentNode.nextElementSibling.style.display = "inline";
+    }
+  }
+
+  const toggleSwitch = document.querySelector('.theme-switch input[type="checkbox"]');
+  function switchTheme(e) {
+      if (e.target.checked) {
+          document.documentElement.setAttribute('data-theme', 'dark');
+          localStorage.setItem('theme', 'dark');
+      } else {
+          document.documentElement.setAttribute('data-theme', 'light');
+          localStorage.setItem('theme', 'light');
+      }
+  }
+
+  toggleSwitch.addEventListener('change', switchTheme, false);
+
+  const currentTheme = localStorage.getItem('theme') ? localStorage.getItem('theme') : null;
+  if (currentTheme) {
+    document.documentElement.setAttribute('data-theme', currentTheme);
+
+    if (currentTheme === 'dark') {
+      toggleSwitch.checked = true;
+    }
+  }
+}
+</script>
+
+</head>
+<body onload="main()">
+<div class="document" id="documentId">
+  <div class="container">
+    <h1 class="title">fftw3/fftshift</h1>
+    <div class="row">
+  <div class="three columns">
+  <div class="theme-switch-wrapper">
+    <label class="theme-switch" for="checkbox">
+      <input type="checkbox" id="checkbox" />
+      <div class="slider round"></div>
+    </label>
+    &nbsp;&nbsp;&nbsp; <em>Dark Mode</em>
+  </div>
+  <div id="global-links">
+    <ul class="simple">
+    <li>
+      <a href="../theindex.html">Index</a>
+    </li>
+    </ul>
+  </div>
+  <div id="searchInputDiv">
+    Search: <input type="text" id="searchInput"
+      onkeyup="search()" />
+  </div>
+  <div>
+    Group by:
+    <select onchange="groupBy(this.value)">
+      <option value="section">Section</option>
+      <option value="type">Type</option>
+    </select>
+  </div>
+  <ul class="simple simple-toc" id="toc-list">
+<li>
+  <a class="reference reference-toplevel" href="#12" id="62">Procs</a>
+  <ul class="simple simple-toc-section">
+      <ul class="simple nested-toc-section">circshift
+      <li><a class="reference" href="#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D"
+    title="circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]">circshift,<wbr>Tensor[T],<wbr>seq[int]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">I
+      <li><a class="reference" href="#I%2CopenArray%5Bint%5D"
+    title="I(coord: openArray[int]): int">I,<wbr>openArray[int]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">ifftshift
+      <li><a class="reference" href="#ifftshift%2CTensor%5BT%5D"
+    title="ifftshift[T](t: Tensor[T]): Tensor[T]">ifftshift,<wbr>Tensor[T]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">J
+      <li><a class="reference" href="#J%2CopenArray%5Bint%5D"
+    title="J(coord: openArray[int]): int">J,<wbr>openArray[int]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">K
+      <li><a class="reference" href="#K%2CopenArray%5Bint%5D"
+    title="K(coord: openArray[int]): int">K,<wbr>openArray[int]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">fftshift
+      <li><a class="reference" href="#fftshift%2CTensor%5BT%5D"
+    title="fftshift[T](t: Tensor[T]): Tensor[T]">fftshift,<wbr>Tensor[T]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">get3DCoord
+      <li><a class="reference" href="#get3DCoord%2Cint%2Cint%2Cint%2Cint"
+    title="get3DCoord(index: int; Nx, Ny, Nz: int): array[3, int]">get3DCoord,<wbr>int,<wbr>int,<wbr>int,<wbr>int</a></li>
+  <li><a class="reference" href="#get3DCoord%2Cint%2CTensor%5BT%5D"
+    title="get3DCoord[T](index: int; t: Tensor[T]): array[3, int]">get3DCoord,<wbr>int,<wbr>Tensor[T]</a></li>
+
+  </ul>
+  <ul class="simple nested-toc-section">get2DCoord
+      <li><a class="reference" href="#get2DCoord%2Cint%2Cint%2Cint"
+    title="get2DCoord(index: int; Nx, Ny: int): array[2, int]">get2DCoord,<wbr>int,<wbr>int,<wbr>int</a></li>
+  <li><a class="reference" href="#get2DCoord%2Cint%2CTensor%5BT%5D"
+    title="get2DCoord[T](index: int; t: Tensor[T]): array[2, int]">get2DCoord,<wbr>int,<wbr>Tensor[T]</a></li>
+
+  </ul>
+
+  </ul>
+</li>
+
+</ul>
+
+  </div>
+  <div class="nine columns" id="content">
+  <div id="tocRoot"></div>
+  
+  <p class="module-desc"></p>
+  <div class="section" id="12">
+<h1><a class="toc-backref" href="#12">Procs</a></h1>
+<dl class="item">
+<a id="get2DCoord,int,int,int"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#get2DCoord%2Cint%2Cint%2Cint"><span class="Identifier">get2DCoord</span></a><span class="Other">(</span><span class="Identifier">index</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">;</span> <span class="Identifier">Nx</span><span class="Other">,</span> <span class="Identifier">Ny</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">array</span><span class="Other">[</span><span class="DecNumber">2</span><span class="Other">,</span> <span class="Identifier">int</span><span class="Other">]</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span><span class="Other">,</span> <span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span>
+    <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="get3DCoord,int,int,int,int"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#get3DCoord%2Cint%2Cint%2Cint%2Cint"><span class="Identifier">get3DCoord</span></a><span class="Other">(</span><span class="Identifier">index</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">;</span> <span class="Identifier">Nx</span><span class="Other">,</span> <span class="Identifier">Ny</span><span class="Other">,</span> <span class="Identifier">Nz</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">array</span><span class="Other">[</span><span class="DecNumber">3</span><span class="Other">,</span> <span class="Identifier">int</span><span class="Other">]</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span><span class="Other">,</span>
+    <span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="get2DCoord,int,Tensor[T]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#get2DCoord%2Cint%2CTensor%5BT%5D"><span class="Identifier">get2DCoord</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">index</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">;</span> <span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">array</span><span class="Other">[</span><span class="DecNumber">2</span><span class="Other">,</span> <span class="Identifier">int</span><span class="Other">]</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="get3DCoord,int,Tensor[T]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#get3DCoord%2Cint%2CTensor%5BT%5D"><span class="Identifier">get3DCoord</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">index</span><span class="Other">:</span> <span class="Identifier">int</span><span class="Other">;</span> <span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">array</span><span class="Other">[</span><span class="DecNumber">3</span><span class="Other">,</span> <span class="Identifier">int</span><span class="Other">]</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="I,openArray[int]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#I%2CopenArray%5Bint%5D"><span class="Identifier">I</span></a><span class="Other">(</span><span class="Identifier">coord</span><span class="Other">:</span> <span class="Identifier">openArray</span><span class="Other">[</span><span class="Identifier">int</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">int</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span><span class="Other">,</span> <span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="J,openArray[int]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#J%2CopenArray%5Bint%5D"><span class="Identifier">J</span></a><span class="Other">(</span><span class="Identifier">coord</span><span class="Other">:</span> <span class="Identifier">openArray</span><span class="Other">[</span><span class="Identifier">int</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">int</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span><span class="Other">,</span> <span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="K,openArray[int]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#K%2CopenArray%5Bint%5D"><span class="Identifier">K</span></a><span class="Other">(</span><span class="Identifier">coord</span><span class="Other">:</span> <span class="Identifier">openArray</span><span class="Other">[</span><span class="Identifier">int</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">int</span> <span><span class="Other">{</span><span class="Other pragmadots">...</span><span class="Other">}</span></span><span class="pragmawrap"><span class="Other">{.</span><span class="pragma"><span class="Identifier">inline</span><span class="Other">,</span> <span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span><span class="Other">.}</span></span></pre></dt>
+<dd>
+
+
+
+</dd>
+<a id="circshift,Tensor[T],seq[int]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D"><span class="Identifier">circshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">;</span> <span class="Identifier">shift</span><span class="Other">:</span> <span class="Identifier">seq</span><span class="Other">[</span><span class="Identifier">int</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
+<dd>
+
+Generic Circshift
+
+</dd>
+<a id="fftshift,Tensor[T]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#fftshift%2CTensor%5BT%5D"><span class="Identifier">fftshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
+<dd>
+
+Common fftshift function. Use Nim's openMP operator (<tt class="docutils literal"><span class="pre">||</span></tt>) for rank &lt;= 3
+<p><strong class="examples_text">Example:</strong></p>
+<pre class="listing"><span class="Keyword">import</span><span class="Whitespace"> </span><span class="Identifier">arraymancer</span><span class="Whitespace">
+</span><span class="Keyword">let</span><span class="Whitespace"> </span><span class="Identifier">input_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">randomTensor</span><span class="Punctuation">[</span><span class="Identifier">float64</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="FloatNumber">10.0</span><span class="Punctuation">)</span><span class="Whitespace">
+</span><span class="Comment"># output_tensor is the fftshift of input_tensor</span><span class="Whitespace">
+</span><span class="Keyword">var</span><span class="Whitespace"> </span><span class="Identifier">output_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">fftshift</span><span class="Punctuation">(</span><span class="Identifier">input_tensor</span><span class="Punctuation">)</span></pre>
+
+</dd>
+<a id="ifftshift,Tensor[T]"></a>
+<dt><pre><span class="Keyword">proc</span> <a href="#ifftshift%2CTensor%5BT%5D"><span class="Identifier">ifftshift</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">(</span><span class="Identifier">t</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span><span class="Other">)</span><span class="Other">:</span> <span class="Identifier">Tensor</span><span class="Other">[</span><span class="Identifier">T</span><span class="Other">]</span></pre></dt>
+<dd>
+
+Common ifftshift function. Use Nim's openMP operator (<tt class="docutils literal"><span class="pre">||</span></tt>) for rank &lt;= 3
+<p><strong class="examples_text">Example:</strong></p>
+<pre class="listing"><span class="Keyword">import</span><span class="Whitespace"> </span><span class="Identifier">arraymancer</span><span class="Whitespace">
+</span><span class="Keyword">let</span><span class="Whitespace"> </span><span class="Identifier">input_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">randomTensor</span><span class="Punctuation">[</span><span class="Identifier">float64</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="DecNumber">10</span><span class="Punctuation">,</span><span class="Whitespace"> </span><span class="FloatNumber">10.0</span><span class="Punctuation">)</span><span class="Whitespace">
+</span><span class="Comment"># output_tensor is the fftshift of input_tensor</span><span class="Whitespace">
+</span><span class="Keyword">var</span><span class="Whitespace"> </span><span class="Identifier">output_tensor</span><span class="Whitespace"> </span><span class="Operator">=</span><span class="Whitespace"> </span><span class="Identifier">ifftshift</span><span class="Punctuation">(</span><span class="Identifier">input_tensor</span><span class="Punctuation">)</span></pre>
+
+</dd>
+
+</dl></div>
+
+  </div>
+</div>
+
+    <div class="row">
+      <div class="twelve-columns footer">
+        <span class="nim-sprite"></span>
+        <br/>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:15 UTC</small>
+      </div>
+    </div>
+  </div>
+</div>
+
+</body>
+</html>
diff --git a/docs/fftw3/fftshift.idx b/docs/fftw3/fftshift.idx
new file mode 100644
index 0000000..bfacdd0
--- /dev/null
+++ b/docs/fftw3/fftshift.idx
@@ -0,0 +1,10 @@
+get2DCoord	fftw3/fftshift.html#get2DCoord,int,int,int	fftshift: get2DCoord(index: int; Nx, Ny: int): array[2, int]	
+get3DCoord	fftw3/fftshift.html#get3DCoord,int,int,int,int	fftshift: get3DCoord(index: int; Nx, Ny, Nz: int): array[3, int]	
+get2DCoord	fftw3/fftshift.html#get2DCoord,int,Tensor[T]	fftshift: get2DCoord[T](index: int; t: Tensor[T]): array[2, int]	
+get3DCoord	fftw3/fftshift.html#get3DCoord,int,Tensor[T]	fftshift: get3DCoord[T](index: int; t: Tensor[T]): array[3, int]	
+I	fftw3/fftshift.html#I,openArray[int]	fftshift: I(coord: openArray[int]): int	
+J	fftw3/fftshift.html#J,openArray[int]	fftshift: J(coord: openArray[int]): int	
+K	fftw3/fftshift.html#K,openArray[int]	fftshift: K(coord: openArray[int]): int	
+circshift	fftw3/fftshift.html#circshift,Tensor[T],seq[int]	fftshift: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]	
+fftshift	fftw3/fftshift.html#fftshift,Tensor[T]	fftshift: fftshift[T](t: Tensor[T]): Tensor[T]	
+ifftshift	fftw3/fftshift.html#ifftshift,Tensor[T]	fftshift: ifftshift[T](t: Tensor[T]): Tensor[T]	
diff --git a/docs/fftw3/guru.html b/docs/fftw3/guru.html
index deb311b..15c460d 100644
--- a/docs/fftw3/guru.html
+++ b/docs/fftw3/guru.html
@@ -440,7 +440,7 @@ <h1><a class="toc-backref" href="#12">Procs</a></h1>
       <div class="twelve-columns footer">
         <span class="nim-sprite"></span>
         <br/>
-        <small style="color: var(--hint);">Made with Nim. Generated: 2020-12-10 16:50:07 UTC</small>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:13 UTC</small>
       </div>
     </div>
   </div>
diff --git a/docs/fftw3/libutils.html b/docs/fftw3/libutils.html
index 683a8c7..8c7de51 100644
--- a/docs/fftw3/libutils.html
+++ b/docs/fftw3/libutils.html
@@ -433,7 +433,7 @@ <h1><a class="toc-backref" href="#12">Procs</a></h1>
       <div class="twelve-columns footer">
         <span class="nim-sprite"></span>
         <br/>
-        <small style="color: var(--hint);">Made with Nim. Generated: 2020-12-10 16:50:07 UTC</small>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:13 UTC</small>
       </div>
     </div>
   </div>
diff --git a/docs/fftw3/wisdom.html b/docs/fftw3/wisdom.html
index ff17f25..821d965 100644
--- a/docs/fftw3/wisdom.html
+++ b/docs/fftw3/wisdom.html
@@ -259,7 +259,7 @@ <h1><a class="toc-backref" href="#12">Procs</a></h1>
       <div class="twelve-columns footer">
         <span class="nim-sprite"></span>
         <br/>
-        <small style="color: var(--hint);">Made with Nim. Generated: 2020-12-10 16:50:07 UTC</small>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:13 UTC</small>
       </div>
     </div>
   </div>
diff --git a/docs/theindex.html b/docs/theindex.html
index d0b9dc5..007aec9 100644
--- a/docs/theindex.html
+++ b/docs/theindex.html
@@ -63,14 +63,14 @@
 <div class="document" id="documentId">
   <div class="container">
     <h1 class="title">Index</h1>
-    Modules: <a href="fftw3.html">fftw3</a>, <a href="fftw3/guru.html">fftw3/guru</a>, <a href="fftw3/libutils.html">fftw3/libutils</a>, <a href="fftw3/wisdom.html">fftw3/wisdom</a>.<br/><p /><h2>API symbols</h2>
+    Modules: <a href="fftw3.html">fftw3</a>, <a href="fftw3/fftshift.html">fftw3/fftshift</a>, <a href="fftw3/guru.html">fftw3/guru</a>, <a href="fftw3/libutils.html">fftw3/libutils</a>, <a href="fftw3/wisdom.html">fftw3/wisdom</a>.<br/><p /><h2>API symbols</h2>
 <dl><dt><a name="circshift" href="#circshift"><span>circshift:</span></a></dt><dd><ul class="simple">
 <li><a class="reference external"
-          data-doc-search-tag="fftw3: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]" href="fftw3.html#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D">fftw3: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]</a></li>
+          data-doc-search-tag="fftshift: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]" href="fftw3/fftshift.html#circshift%2CTensor%5BT%5D%2Cseq%5Bint%5D">fftshift: circshift[T](t: Tensor[T]; shift: seq[int]): Tensor[T]</a></li>
           </ul></dd>
 <dt><a name="fftshift" href="#fftshift"><span>fftshift:</span></a></dt><dd><ul class="simple">
 <li><a class="reference external"
-          data-doc-search-tag="fftw3: fftshift[T](t: Tensor[T]): Tensor[T]" href="fftw3.html#fftshift%2CTensor%5BT%5D">fftw3: fftshift[T](t: Tensor[T]): Tensor[T]</a></li>
+          data-doc-search-tag="fftshift: fftshift[T](t: Tensor[T]): Tensor[T]" href="fftw3/fftshift.html#fftshift%2CTensor%5BT%5D">fftshift: fftshift[T](t: Tensor[T]): Tensor[T]</a></li>
           </ul></dd>
 <dt><a name="Fftw3Lib" href="#Fftw3Lib"><span>Fftw3Lib:</span></a></dt><dd><ul class="simple">
 <li><a class="reference external"
@@ -676,9 +676,33 @@ <h1 class="title">Index</h1>
 <li><a class="reference external"
           data-doc-search-tag="libutils: fftw_write_char_func" href="fftw3/libutils.html#fftw_write_char_func">libutils: fftw_write_char_func</a></li>
           </ul></dd>
+<dt><a name="get2DCoord" href="#get2DCoord"><span>get2DCoord:</span></a></dt><dd><ul class="simple">
+<li><a class="reference external"
+          data-doc-search-tag="fftshift: get2DCoord(index: int; Nx, Ny: int): array[2, int]" href="fftw3/fftshift.html#get2DCoord%2Cint%2Cint%2Cint">fftshift: get2DCoord(index: int; Nx, Ny: int): array[2, int]</a></li>
+          <li><a class="reference external"
+          data-doc-search-tag="fftshift: get2DCoord[T](index: int; t: Tensor[T]): array[2, int]" href="fftw3/fftshift.html#get2DCoord%2Cint%2CTensor%5BT%5D">fftshift: get2DCoord[T](index: int; t: Tensor[T]): array[2, int]</a></li>
+          </ul></dd>
+<dt><a name="get3DCoord" href="#get3DCoord"><span>get3DCoord:</span></a></dt><dd><ul class="simple">
+<li><a class="reference external"
+          data-doc-search-tag="fftshift: get3DCoord(index: int; Nx, Ny, Nz: int): array[3, int]" href="fftw3/fftshift.html#get3DCoord%2Cint%2Cint%2Cint%2Cint">fftshift: get3DCoord(index: int; Nx, Ny, Nz: int): array[3, int]</a></li>
+          <li><a class="reference external"
+          data-doc-search-tag="fftshift: get3DCoord[T](index: int; t: Tensor[T]): array[3, int]" href="fftw3/fftshift.html#get3DCoord%2Cint%2CTensor%5BT%5D">fftshift: get3DCoord[T](index: int; t: Tensor[T]): array[3, int]</a></li>
+          </ul></dd>
+<dt><a name="I" href="#I"><span>I:</span></a></dt><dd><ul class="simple">
+<li><a class="reference external"
+          data-doc-search-tag="fftshift: I(coord: openArray[int]): int" href="fftw3/fftshift.html#I%2CopenArray%5Bint%5D">fftshift: I(coord: openArray[int]): int</a></li>
+          </ul></dd>
 <dt><a name="ifftshift" href="#ifftshift"><span>ifftshift:</span></a></dt><dd><ul class="simple">
 <li><a class="reference external"
-          data-doc-search-tag="fftw3: ifftshift[T](t: Tensor[T]): Tensor[T]" href="fftw3.html#ifftshift%2CTensor%5BT%5D">fftw3: ifftshift[T](t: Tensor[T]): Tensor[T]</a></li>
+          data-doc-search-tag="fftshift: ifftshift[T](t: Tensor[T]): Tensor[T]" href="fftw3/fftshift.html#ifftshift%2CTensor%5BT%5D">fftshift: ifftshift[T](t: Tensor[T]): Tensor[T]</a></li>
+          </ul></dd>
+<dt><a name="J" href="#J"><span>J:</span></a></dt><dd><ul class="simple">
+<li><a class="reference external"
+          data-doc-search-tag="fftshift: J(coord: openArray[int]): int" href="fftw3/fftshift.html#J%2CopenArray%5Bint%5D">fftshift: J(coord: openArray[int]): int</a></li>
+          </ul></dd>
+<dt><a name="K" href="#K"><span>K:</span></a></dt><dd><ul class="simple">
+<li><a class="reference external"
+          data-doc-search-tag="fftshift: K(coord: openArray[int]): int" href="fftw3/fftshift.html#K%2CopenArray%5Bint%5D">fftshift: K(coord: openArray[int]): int</a></li>
           </ul></dd>
 <dt><a name="ptrdiff_t" href="#ptrdiff_t"><span>ptrdiff_t:</span></a></dt><dd><ul class="simple">
 <li><a class="reference external"
@@ -693,7 +717,7 @@ <h1 class="title">Index</h1>
       <div class="twelve-columns footer">
         <span class="nim-sprite"></span>
         <br/>
-        <small style="color: var(--hint);">Made with Nim. Generated: 2020-12-10 16:50:09 UTC</small>
+        <small style="color: var(--hint);">Made with Nim. Generated: 2021-02-03 11:06:17 UTC</small>
       </div>
     </div>
   </div>
diff --git a/src/fftw3.nim b/src/fftw3.nim
index 8036e0a..1073121 100644
--- a/src/fftw3.nim
+++ b/src/fftw3.nim
@@ -46,15 +46,16 @@
 import arraymancer
 import sequtils
 import complex
-import arraymancer/tensor/private/p_accessors
 import fftw3/libutils
 # Import mostly for documentation links
 {.push warning[UnusedImport]: off.}
 import fftw3/guru, fftw3/wisdom
 {.pop.}
+import fftw3/fftshift
 # export used types
 export fftw_plan
 export fftw_r2r_kind
+export fftshift
 
 const
     FFTW_MEASURE* = 0  ## ``fftw_plan`` planner flag.
@@ -92,95 +93,6 @@ const
     ##
     ## Compute an inverse DFT transform.
 
-
-# FFT Shift
-proc circshift_impl[T](t: Tensor[T], xshift: int, yshift: int, zshift: int): Tensor[T] =
-  assert(t.rank == 3)
-  var X = t.shape[0]
-  var Y = t.shape[1]
-  var Z = t.shape[2]
-
-  result = newTensor[T](t.shape.toSeq)
-  for i in 0||(X-1):
-    var ii = (i + xshift) mod X
-    for j in 0||(Y-1):
-      var jj = (j + yshift) mod Y
-      for k in 0||(Z-1):
-        var kk = (k + zshift) mod Z
-        result[ii, jj, kk] = t[i, j, k]
-
-proc circshift_impl[T](t: Tensor[T], xshift: int, yshift: int): Tensor[T] =
-  assert(t.rank == 2)
-  var X = t.shape[0]
-  var Y = t.shape[1]
-
-  result = newTensor[T](t.shape.toSeq)
-  for i in 0||(X-1):
-    var ii = (i + xshift) mod X
-    for j in 0||(Y-1):
-      var jj = (j + yshift) mod Y
-      result[ii, jj] = t[i, j]
-
-proc circshift_impl[T](t: Tensor[T], xshift: int): Tensor[T] =
-  assert(t.rank == 1)
-  var X = t.shape[0]
-
-  result = newTensor[T](t.shape.toSeq)
-  for i in 0||(X-1):
-    var ii = (i + xshift) mod X
-    result[ii] = t[i]
-
-# TODO : Generic implementation in parallel
-proc circshift_impl[T](t: Tensor[T], shift: seq[int]): Tensor[T] =
-  let shape = t.shape.toSeq
-  result = newTensor[T](t.shape.toSeq)
-  for coord, values in t:
-    var newcoord: seq[int] = newSeq[int](t.rank)
-    for i in 0..<t.rank:
-      newcoord[i] = (coord[i]+shift[i]) mod shape[i]
-    result.atIndexMut(newcoord, values)
-
-proc circshift*[T](t: Tensor[T], shift: seq[int]): Tensor[T] =
-  ## Generic Circshift
-  assert(t.rank == shift.len)
-  case t.rank
-  of 1:
-    result = circshift_impl(t, shift[0])
-  of 2:
-    result = circshift_impl(t, shift[0], shift[1])
-  of 3:
-    result = circshift_impl(t, shift[0], shift[1], shift[2])
-  else:
-    result = circshift_impl(t, shift)
-
-proc fftshift*[T](t: Tensor[T]): Tensor[T] =
-  ## Common fftshift function. Use Nim's openMP operator (`||`) for rank <= 3
-  runnableExamples:
-    import arraymancer
-    let input_tensor = randomTensor[float64](10, 10, 10, 10.0)
-    # output_tensor is the fftshift of input_tensor
-    var output_tensor = fftshift(input_tensor)
-
-  # Calculate fftshift using circshift
-  let xshift = t.shape[0] div 2
-  let yshift = t.shape[1] div 2
-  let zshift = t.shape[2] div 2
-  result = circshift(t, @[xshift.int, yshift.int, zshift.int])
-
-proc ifftshift*[T](t: Tensor[T]): Tensor[T] =
-  ## Common ifftshift function. Use Nim's openMP operator (`||`) for rank <= 3
-  runnableExamples:
-    import arraymancer
-    let input_tensor = randomTensor[float64](10, 10, 10, 10.0)
-    # output_tensor is the fftshift of input_tensor
-    var output_tensor = ifftshift(input_tensor)
-
-  # Calculate inverse fftshift using circshift
-  let xshift = (t.shape[0]+1) div 2
-  let yshift = (t.shape[1]+1) div 2
-  let zshift = (t.shape[2]+1) div 2
-  result = circshift(t, @[xshift.int, yshift.int, zshift.int])
-
 # FFTW Execute API
 proc fftw_execute*(p: fftw_plan) {.cdecl, importc: "fftw_execute", dynlib: Fftw3Lib.}
   ## Execute a plan
diff --git a/src/fftw3/fftshift.nim b/src/fftw3/fftshift.nim
new file mode 100644
index 0000000..6dcec40
--- /dev/null
+++ b/src/fftw3/fftshift.nim
@@ -0,0 +1,144 @@
+import arraymancer
+import arraymancer/tensor/private/p_accessors
+
+import sequtils
+
+proc get2DCoord*(index: int, Nx, Ny: int): array[2, int] {.inline.} =
+  var index = index
+  result[0] = index div Ny
+  index = index - result[0]*Ny
+  result[1] = index
+
+proc get3DCoord*(index: int, Nx, Ny, Nz: int): array[3, int] {.inline.} =
+  var index = index
+  result[0] = index div (Nz*Ny)
+  index = index - result[0]*Nz*Ny
+  result[1] = index div Nz
+  index = index - result[1]*Nz
+  result[2] = index
+
+proc get2DCoord*[T](index: int, t: Tensor[T]): array[2, int] {.inline.} =
+  doAssert t.rank == 2
+  let Nx = t.shape[0]
+  let Ny = t.shape[1]
+  result = get2DCoord(index, Nx, Ny)
+
+proc get3DCoord*[T](index: int, t: Tensor[T]): array[3, int] {.inline.} =
+  doAssert t.rank == 3
+  let Nx = t.shape[0]
+  let Ny = t.shape[1]
+  let Nz = t.shape[2]
+  result = get3DCoord(index, Nx, Ny, Nz)
+
+proc I*(coord: openArray[int]): int {.inline.} =
+  return coord[0]
+
+proc J*(coord: openArray[int]): int {.inline.} =
+  return coord[1]
+
+proc K*(coord: openArray[int]): int {.inline.} =
+  return coord[2]
+
+# FFT Shift
+proc circshift_impl[T](t: Tensor[T], xshift: int, yshift: int, zshift: int): Tensor[T] =
+  assert(t.rank == 3)
+  let
+    X = t.shape[0]
+    Y = t.shape[1]
+    Z = t.shape[2]
+  result = newTensor[T](X, Y, Z)
+  for idx in 0||(result.size-1):
+    let
+      coord = idx.get3DCoord(result)
+      ii = (coord.I + xshift) mod X
+      jj = (coord.J + xshift) mod X
+      kk = (coord.K + xshift) mod X
+    result[ii, jj, kk] = t[coord.I, coord.J, coord.K]
+
+  # for i in 0||(X-1):
+  #   var ii = (i + xshift) mod X
+  #   for j in 0||(Y-1):
+  #     var jj = (j + yshift) mod Y
+  #     for k in 0||(Z-1):
+  #       var kk = (k + zshift) mod Z
+  #       result[ii, jj, kk] = t[i, j, k]
+
+proc circshift_impl[T](t: Tensor[T], xshift: int, yshift: int): Tensor[T] =
+  assert(t.rank == 2)
+  let
+    X = t.shape[0]
+    Y = t.shape[1]
+  result = newTensor[T](X, Y)
+  for idx in 0||(result.size-1):
+    let
+      coord = idx.get2DCoord(result)
+      ii = (coord.I + xshift) mod X
+      jj = (coord.J + xshift) mod X
+    result[ii, jj] = t[coord.I, coord.J]
+
+  # for i in 0||(X-1):
+  #   var ii = (i + xshift) mod X
+  #   for j in 0||(Y-1):
+  #     var jj = (j + yshift) mod Y
+  #     result[ii, jj] = t[i, j]
+
+proc circshift_impl[T](t: Tensor[T], xshift: int): Tensor[T] =
+  assert(t.rank == 1)
+  var X = t.shape[0]
+
+  result = newTensor[T](t.shape.toSeq)
+  for i in 0||(X-1):
+    var ii = (i + xshift) mod X
+    result[ii] = t[i]
+
+# TODO : Generic implementation in parallel
+proc circshift_impl[T](t: Tensor[T], shift: seq[int]): Tensor[T] =
+  let shape = t.shape.toSeq
+  result = newTensor[T](t.shape.toSeq)
+  for coord, values in t:
+    var newcoord: seq[int] = newSeq[int](t.rank)
+    for i in 0..<t.rank:
+      newcoord[i] = (coord[i]+shift[i]) mod shape[i]
+    result.atIndexMut(newcoord, values)
+
+proc circshift*[T](t: Tensor[T], shift: seq[int]): Tensor[T] =
+  ## Generic Circshift
+  assert(t.rank == shift.len)
+  case t.rank
+  of 1:
+    result = circshift_impl(t, shift[0])
+  of 2:
+    result = circshift_impl(t, shift[0], shift[1])
+  of 3:
+    result = circshift_impl(t, shift[0], shift[1], shift[2])
+  else:
+    result = circshift_impl(t, shift)
+
+proc fftshift*[T](t: Tensor[T]): Tensor[T] =
+  ## Common fftshift function. Use Nim's openMP operator (`||`) for rank <= 3
+  runnableExamples:
+    import arraymancer
+    let input_tensor = randomTensor[float64](10, 10, 10, 10.0)
+    # output_tensor is the fftshift of input_tensor
+    var output_tensor = fftshift(input_tensor)
+
+  # Calculate fftshift using circshift
+  let xshift = t.shape[0] div 2
+  let yshift = t.shape[1] div 2
+  let zshift = t.shape[2] div 2
+  result = circshift(t, @[xshift.int, yshift.int, zshift.int])
+
+proc ifftshift*[T](t: Tensor[T]): Tensor[T] =
+  ## Common ifftshift function. Use Nim's openMP operator (`||`) for rank <= 3
+  runnableExamples:
+    import arraymancer
+    let input_tensor = randomTensor[float64](10, 10, 10, 10.0)
+    # output_tensor is the fftshift of input_tensor
+    var output_tensor = ifftshift(input_tensor)
+
+  # Calculate inverse fftshift using circshift
+  let xshift = (t.shape[0]+1) div 2
+  let yshift = (t.shape[1]+1) div 2
+  let zshift = (t.shape[2]+1) div 2
+  result = circshift(t, @[xshift.int, yshift.int, zshift.int])
+