lattice/pyerrors
1
0
Fork 0
mirror of https://github.com/fjosw/pyerrors.git synced 2025-05-15 12:03:42 +02:00
Code Issues Projects Releases Packages Wiki Activity

Documentation updated

Browse source
This commit is contained in:
fjosw 2022-01-18 16:51:32 +00:00
parent cfb6f65a8c
commit 4417666660
2 changed files with 104 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

247
docs/pyerrors/correlators.html
View file

@ -185,15 +185,9 @@
</ul>
</li>
<li>
<a class="function" href="#sort_vectors">sort_vectors</a>
</li>
<li>
<a class="function" href="#permutation">permutation</a>
</li>
<li>
<a class="function" href="#GEVP_solver">GEVP_solver</a>
</li>
</ul>
@ -316,15 +310,15 @@
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">N</span><span class="p">):</span>
<span class="n">item</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">gamma_method</span><span class="p">(</span><span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
<span class="c1"># We need to project the Correlator with a Vector to get a single value at each timeslice.</span>
<span class="c1"># The method can use one or two vectors.</span>
<span class="c1"># If two are specified it returns v1@G@v2 (the order might be very important.)</span>
<span class="c1"># By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</span>
<span class="k">def</span> <span class="nf">projected</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">vector_l</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">vector_r</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">normalize</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;We need to project the Correlator with a Vector to get a single value at each timeslice.</span>
<span class="sd"> The method can use one or two vectors.</span>
<span class="sd"> If two are specified it returns v1@G@v2 (the order might be very important.)</span>
<span class="sd"> By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Trying to project a Corr, that already has N=1.&quot;</span><span class="p">)</span>
<span class="c1"># This Exception is in no way necessary. One could just return self</span>
<span class="c1"># But there is no scenario, where a user would want that to happen and the error message might be more informative.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">gamma_method</span><span class="p">()</span>
@ -370,8 +364,6 @@
<span class="n">newcontent</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span> <span class="k">if</span><span class="p">(</span><span class="n">item</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span> <span class="k">else</span> <span class="n">item</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="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">]</span>
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">)</span>
<span class="c1"># Obs and Matplotlib do not play nicely</span>
<span class="c1"># We often want to retrieve x,y,y_err as lists to pass them to something like pyplot.errorbar</span>
<span class="k">def</span> <span class="nf">plottable</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Outputs the correlator in a plotable format.</span>
@ -386,9 +378,6 @@
<span class="k">return</span> <span class="n">x_list</span><span class="p">,</span> <span class="n">y_list</span><span class="p">,</span> <span class="n">y_err_list</span>
<span class="c1"># symmetric returns a Corr, that has been symmetrized.</span>
<span class="c1"># A symmetry checker is still to be implemented</span>
<span class="c1"># The method will not delete any redundant timeslices (Bad for memory, Great for convenience)</span>
<span class="k">def</span> <span class="nf">symmetric</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot; Symmetrize the correlator around x0=0.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">T</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
@ -425,8 +414,8 @@
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Corr could not be symmetrized: No redundant values&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">,</span> <span class="n">prange</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">prange</span><span class="p">)</span>
<span class="c1"># This method will symmetrice the matrices and therefore make them positive definit.</span>
<span class="k">def</span> <span class="nf">smearing_symmetric</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Symmetrizes the matrices and therefore make them positive definite.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">transposed</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span> <span class="k">if</span> <span class="p">(</span><span class="n">G</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span> <span class="k">else</span> <span class="n">G</span><span class="o">.</span><span class="n">T</span> <span class="k">for</span> <span class="n">G</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">]</span>
<span class="k">return</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="p">(</span><span class="n">Corr</span><span class="p">(</span><span class="n">transposed</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="p">)</span>
@ -446,7 +435,7 @@
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">ts</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="k">return</span> <span class="n">sp_vec</span>
<span class="k">if</span> <span class="n">return_list</span><span class="p">:</span>
@ -459,16 +448,16 @@
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvalue&quot;</span><span class="p">:</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vec</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vecs</span><span class="p">)</span>
<span class="k">except</span> <span class="s2">&quot;Failure to solve for one timeslice&quot;</span><span class="p">:</span> <span class="c1"># This could contain a check for real eigenvectors</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvector&quot;</span><span class="p">:</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">_sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">a</span><span class="p">[</span><span class="n">state</span><span class="p">]</span> <span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">all_vecs</span><span class="p">]</span>
<span class="k">return</span> <span class="n">all_vecs</span>
@ -493,11 +482,20 @@
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">Hankel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">periodic</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="c1"># Constructs an NxN Hankel matrix</span>
<span class="c1"># C(t) c(t+1) ... c(t+n-1)</span>
<span class="c1"># C(t+1) c(t+2) ... c(t+n)</span>
<span class="c1"># .................</span>
<span class="c1"># C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd">&quot;&quot;&quot;Constructs an NxN Hankel matrix</span>
<span class="sd"> C(t) c(t+1) ... c(t+n-1)</span>
<span class="sd"> C(t+1) c(t+2) ... c(t+n)</span>
<span class="sd"> .................</span>
<span class="sd"> C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd"> Parameters:</span>
<span class="sd"> -----------</span>
<span class="sd"> N : int</span>
<span class="sd"> Dimension of the Hankel matrix</span>
<span class="sd"> periodic : bool, optional</span>
<span class="sd"> determines whether the matrix is extended periodically</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Multi-operator Prony not implemented!&quot;</span><span class="p">)</span>
@ -734,11 +732,6 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Correlator must be projected before fitting&quot;</span><span class="p">)</span>
<span class="c1"># The default behavior is:</span>
<span class="c1"># 1 use explicit fitrange</span>
<span class="c1"># if none is provided, use the range of the corr</span>
<span class="c1"># if this is also not set, use the whole length of the corr (This could come with a warning!)</span>
<span class="k">if</span> <span class="n">fitrange</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span><span class="p">:</span>
<span class="n">fitrange</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span>
@ -1138,7 +1131,8 @@
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_apply_func_to_corr</span><span class="p">(</span><span class="n">return_imag</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">sort_vectors</span><span class="p">(</span><span class="n">vec_set</span><span class="p">,</span> <span class="n">ts</span><span class="p">):</span> <span class="c1"># Helper function used to find a set of Eigenvectors consistent over all timeslices</span>
<span class="k">def</span> <span class="nf">_sort_vectors</span><span class="p">(</span><span class="n">vec_set</span><span class="p">,</span> <span class="n">ts</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Helper function used to find a set of Eigenvectors consistent over all timeslices&quot;&quot;&quot;</span>
<span class="n">reference_sorting</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="n">vec_set</span><span class="p">[</span><span class="n">ts</span><span class="p">])</span>
<span class="n">N</span> <span class="o">=</span> <span class="n">reference_sorting</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">sorted_vec_set</span> <span class="o">=</span> <span class="p">[]</span>
@ -1157,7 +1151,6 @@
<span class="k">if</span> <span class="n">current_score</span> <span class="o">&gt;</span> <span class="n">best_score</span><span class="p">:</span>
<span class="n">best_score</span> <span class="o">=</span> <span class="n">current_score</span>
<span class="n">best_perm</span> <span class="o">=</span> <span class="n">perm</span>
<span class="c1"># print(&quot;best perm&quot;, best_perm)</span>
<span class="n">sorted_vec_set</span><span class="o">.</span><span class="n">append</span><span class="p">([</span><span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">best_perm</span><span class="p">])</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sorted_vec_set</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">])</span>
@ -1178,7 +1171,7 @@
<span class="k">return</span> <span class="n">ll</span>
<span class="k">def</span> <span class="nf">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">):</span> <span class="c1"># Just so normalization an sorting does not need to be repeated. Here we could later put in some checks</span>
<span class="k">def</span> <span class="nf">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">):</span> <span class="c1"># Just so normalization an sorting does not need to be repeated. Here we could later put in some checks</span>
<span class="n">sp_val</span><span class="p">,</span> <span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">scipy</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">eig</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">sp_vecs</span><span class="p">[:,</span> <span class="n">np</span><span class="o">.</span><span class="n">argsort</span><span class="p">(</span><span class="n">sp_val</span><span class="p">)[</span><span class="o">-</span><span class="n">i</span><span class="p">]]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">sp_vecs</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)]</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">v</span> <span class="o">/</span> <span class="n">np</span><span class="o">.</span><span class="n">sqrt</span><span class="p">((</span><span class="n">v</span><span class="o">.</span><span class="n">T</span> <span class="o">@</span> <span class="n">G0</span> <span class="o">@</span> <span class="n">v</span><span class="p">))</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">sp_vecs</span><span class="p">]</span>
@ -1290,15 +1283,15 @@
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">N</span><span class="p">):</span>
<span class="n">item</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">gamma_method</span><span class="p">(</span><span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
<span class="c1"># We need to project the Correlator with a Vector to get a single value at each timeslice.</span>
<span class="c1"># The method can use one or two vectors.</span>
<span class="c1"># If two are specified it returns v1@G@v2 (the order might be very important.)</span>
<span class="c1"># By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</span>
<span class="k">def</span> <span class="nf">projected</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">vector_l</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">vector_r</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">normalize</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;We need to project the Correlator with a Vector to get a single value at each timeslice.</span>
<span class="sd"> The method can use one or two vectors.</span>
<span class="sd"> If two are specified it returns v1@G@v2 (the order might be very important.)</span>
<span class="sd"> By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Trying to project a Corr, that already has N=1.&quot;</span><span class="p">)</span>
<span class="c1"># This Exception is in no way necessary. One could just return self</span>
<span class="c1"># But there is no scenario, where a user would want that to happen and the error message might be more informative.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">gamma_method</span><span class="p">()</span>
@ -1344,8 +1337,6 @@
<span class="n">newcontent</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span> <span class="k">if</span><span class="p">(</span><span class="n">item</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span> <span class="k">else</span> <span class="n">item</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="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">]</span>
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">)</span>
<span class="c1"># Obs and Matplotlib do not play nicely</span>
<span class="c1"># We often want to retrieve x,y,y_err as lists to pass them to something like pyplot.errorbar</span>
<span class="k">def</span> <span class="nf">plottable</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Outputs the correlator in a plotable format.</span>
@ -1360,9 +1351,6 @@
<span class="k">return</span> <span class="n">x_list</span><span class="p">,</span> <span class="n">y_list</span><span class="p">,</span> <span class="n">y_err_list</span>
<span class="c1"># symmetric returns a Corr, that has been symmetrized.</span>
<span class="c1"># A symmetry checker is still to be implemented</span>
<span class="c1"># The method will not delete any redundant timeslices (Bad for memory, Great for convenience)</span>
<span class="k">def</span> <span class="nf">symmetric</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot; Symmetrize the correlator around x0=0.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">T</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">:</span>
@ -1399,8 +1387,8 @@
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Corr could not be symmetrized: No redundant values&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">,</span> <span class="n">prange</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">prange</span><span class="p">)</span>
<span class="c1"># This method will symmetrice the matrices and therefore make them positive definit.</span>
<span class="k">def</span> <span class="nf">smearing_symmetric</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Symmetrizes the matrices and therefore make them positive definite.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">transposed</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span> <span class="k">if</span> <span class="p">(</span><span class="n">G</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span> <span class="k">else</span> <span class="n">G</span><span class="o">.</span><span class="n">T</span> <span class="k">for</span> <span class="n">G</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">]</span>
<span class="k">return</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="p">(</span><span class="n">Corr</span><span class="p">(</span><span class="n">transposed</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="p">)</span>
@ -1420,7 +1408,7 @@
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">ts</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="k">return</span> <span class="n">sp_vec</span>
<span class="k">if</span> <span class="n">return_list</span><span class="p">:</span>
@ -1433,16 +1421,16 @@
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvalue&quot;</span><span class="p">:</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vec</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vecs</span><span class="p">)</span>
<span class="k">except</span> <span class="s2">&quot;Failure to solve for one timeslice&quot;</span><span class="p">:</span> <span class="c1"># This could contain a check for real eigenvectors</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvector&quot;</span><span class="p">:</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">_sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">a</span><span class="p">[</span><span class="n">state</span><span class="p">]</span> <span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">all_vecs</span><span class="p">]</span>
<span class="k">return</span> <span class="n">all_vecs</span>
@ -1467,11 +1455,20 @@
<span class="k">return</span> <span class="n">Corr</span><span class="p">(</span><span class="n">newcontent</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">Hankel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">periodic</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="c1"># Constructs an NxN Hankel matrix</span>
<span class="c1"># C(t) c(t+1) ... c(t+n-1)</span>
<span class="c1"># C(t+1) c(t+2) ... c(t+n)</span>
<span class="c1"># .................</span>
<span class="c1"># C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd">&quot;&quot;&quot;Constructs an NxN Hankel matrix</span>
<span class="sd"> C(t) c(t+1) ... c(t+n-1)</span>
<span class="sd"> C(t+1) c(t+2) ... c(t+n)</span>
<span class="sd"> .................</span>
<span class="sd"> C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd"> Parameters:</span>
<span class="sd"> -----------</span>
<span class="sd"> N : int</span>
<span class="sd"> Dimension of the Hankel matrix</span>
<span class="sd"> periodic : bool, optional</span>
<span class="sd"> determines whether the matrix is extended periodically</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Multi-operator Prony not implemented!&quot;</span><span class="p">)</span>
@ -1708,11 +1705,6 @@
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Correlator must be projected before fitting&quot;</span><span class="p">)</span>
<span class="c1"># The default behavior is:</span>
<span class="c1"># 1 use explicit fitrange</span>
<span class="c1"># if none is provided, use the range of the corr</span>
<span class="c1"># if this is also not set, use the whole length of the corr (This could come with a warning!)</span>
<span class="k">if</span> <span class="n">fitrange</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span><span class="p">:</span>
<span class="n">fitrange</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span>
@ -2254,10 +2246,14 @@ region indentified for this correlator.</li>
<details>
<summary>View Source</summary>
<div class="codehilite"><pre><span></span> <span class="k">def</span> <span class="nf">projected</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">vector_l</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">vector_r</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">normalize</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;We need to project the Correlator with a Vector to get a single value at each timeslice.</span>
<span class="sd"> The method can use one or two vectors.</span>
<span class="sd"> If two are specified it returns v1@G@v2 (the order might be very important.)</span>
<span class="sd"> By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Trying to project a Corr, that already has N=1.&quot;</span><span class="p">)</span>
<span class="c1"># This Exception is in no way necessary. One could just return self</span>
<span class="c1"># But there is no scenario, where a user would want that to happen and the error message might be more informative.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">gamma_method</span><span class="p">()</span>
@ -2296,7 +2292,13 @@ region indentified for this correlator.</li>
</details>
<div class="docstring"><p>We need to project the Correlator with a Vector to get a single value at each timeslice.</p>
<p>The method can use one or two vectors.
If two are specified it returns v1@G@v2 (the order might be very important.)
By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to</p>
</div>
</div>
<div id="Corr.sum" class="classattr">
@ -2458,6 +2460,7 @@ timeslice and the error on each timeslice.</p>
<details>
<summary>View Source</summary>
<div class="codehilite"><pre><span></span> <span class="k">def</span> <span class="nf">smearing_symmetric</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Symmetrizes the matrices and therefore make them positive definite.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">transposed</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span> <span class="k">if</span> <span class="p">(</span><span class="n">G</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">)</span> <span class="k">else</span> <span class="n">G</span><span class="o">.</span><span class="n">T</span> <span class="k">for</span> <span class="n">G</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">]</span>
<span class="k">return</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="p">(</span><span class="n">Corr</span><span class="p">(</span><span class="n">transposed</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="p">)</span>
@ -2467,7 +2470,9 @@ timeslice and the error on each timeslice.</p>
</details>
<div class="docstring"><p>Symmetrizes the matrices and therefore make them positive definite.</p>
</div>
</div>
<div id="Corr.GEVP" class="classattr">
@ -2490,7 +2495,7 @@ timeslice and the error on each timeslice.</p>
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">ts</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="k">return</span> <span class="n">sp_vec</span>
<span class="k">if</span> <span class="n">return_list</span><span class="p">:</span>
@ -2503,16 +2508,16 @@ timeslice and the error on each timeslice.</p>
<span class="n">G0</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t0</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">value</span>
<span class="n">Gt</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="bp">self</span><span class="o">.</span><span class="n">content</span><span class="p">[</span><span class="n">t</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">value</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">_GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvalue&quot;</span><span class="p">:</span>
<span class="n">sp_vec</span> <span class="o">=</span> <span class="n">sp_vecs</span><span class="p">[</span><span class="n">state</span><span class="p">]</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vec</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">sp_vecs</span><span class="p">)</span>
<span class="k">except</span> <span class="s2">&quot;Failure to solve for one timeslice&quot;</span><span class="p">:</span> <span class="c1"># This could contain a check for real eigenvectors</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
<span class="n">all_vecs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sorting</span> <span class="o">==</span> <span class="s2">&quot;Eigenvector&quot;</span><span class="p">:</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="n">_sort_vectors</span><span class="p">(</span><span class="n">all_vecs</span><span class="p">,</span> <span class="n">ts</span><span class="p">)</span>
<span class="n">all_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">a</span><span class="p">[</span><span class="n">state</span><span class="p">]</span> <span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">all_vecs</span><span class="p">]</span>
<span class="k">return</span> <span class="n">all_vecs</span>
@ -2569,11 +2574,20 @@ timeslice and the error on each timeslice.</p>
<details>
<summary>View Source</summary>
<div class="codehilite"><pre><span></span> <span class="k">def</span> <span class="nf">Hankel</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">periodic</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="c1"># Constructs an NxN Hankel matrix</span>
<span class="c1"># C(t) c(t+1) ... c(t+n-1)</span>
<span class="c1"># C(t+1) c(t+2) ... c(t+n)</span>
<span class="c1"># .................</span>
<span class="c1"># C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd">&quot;&quot;&quot;Constructs an NxN Hankel matrix</span>
<span class="sd"> C(t) c(t+1) ... c(t+n-1)</span>
<span class="sd"> C(t+1) c(t+2) ... c(t+n)</span>
<span class="sd"> .................</span>
<span class="sd"> C(t+(n-1)) c(t+n) ... c(t+2(n-1))</span>
<span class="sd"> Parameters:</span>
<span class="sd"> -----------</span>
<span class="sd"> N : int</span>
<span class="sd"> Dimension of the Hankel matrix</span>
<span class="sd"> periodic : bool, optional</span>
<span class="sd"> determines whether the matrix is extended periodically</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Multi-operator Prony not implemented!&quot;</span><span class="p">)</span>
@ -2603,7 +2617,21 @@ timeslice and the error on each timeslice.</p>
</details>
<div class="docstring"><p>Constructs an NxN Hankel matrix</p>
<p>C(t) c(t+1) ... c(t+n-1)
C(t+1) c(t+2) ... c(t+n)
.................
C(t+(n-1)) c(t+n) ... c(t+2(n-1))</p>
<h2 id="parameters">Parameters:</h2>
<p>N : int
Dimension of the Hankel matrix
periodic : bool, optional
determines whether the matrix is extended periodically</p>
</div>
</div>
<div id="Corr.roll" class="classattr">
@ -3027,11 +3055,6 @@ guess for the root finder, only relevant for the root variant</li>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">N</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Correlator must be projected before fitting&quot;</span><span class="p">)</span>
<span class="c1"># The default behavior is:</span>
<span class="c1"># 1 use explicit fitrange</span>
<span class="c1"># if none is provided, use the range of the corr</span>
<span class="c1"># if this is also not set, use the whole length of the corr (This could come with a warning!)</span>
<span class="k">if</span> <span class="n">fitrange</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span><span class="p">:</span>
<span class="n">fitrange</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prange</span>
@ -3653,48 +3676,6 @@ specifies a custom path for the file (default '.')</li>
</div>
</section>
<section id="sort_vectors">
<div class="attr function"><a class="headerlink" href="#sort_vectors">#&nbsp;&nbsp</a>
<span class="def">def</span>
<span class="name">sort_vectors</span><span class="signature">(vec_set, ts)</span>:
</div>
<details>
<summary>View Source</summary>
<div class="codehilite"><pre><span></span><span class="k">def</span> <span class="nf">sort_vectors</span><span class="p">(</span><span class="n">vec_set</span><span class="p">,</span> <span class="n">ts</span><span class="p">):</span> <span class="c1"># Helper function used to find a set of Eigenvectors consistent over all timeslices</span>
<span class="n">reference_sorting</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="n">vec_set</span><span class="p">[</span><span class="n">ts</span><span class="p">])</span>
<span class="n">N</span> <span class="o">=</span> <span class="n">reference_sorting</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">sorted_vec_set</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">vec_set</span><span class="p">)):</span>
<span class="k">if</span> <span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">sorted_vec_set</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="k">elif</span> <span class="ow">not</span> <span class="n">t</span> <span class="o">==</span> <span class="n">ts</span><span class="p">:</span>
<span class="n">perms</span> <span class="o">=</span> <span class="n">permutation</span><span class="p">([</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">N</span><span class="p">)])</span>
<span class="n">best_score</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">perm</span> <span class="ow">in</span> <span class="n">perms</span><span class="p">:</span>
<span class="n">current_score</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">N</span><span class="p">):</span>
<span class="n">new_sorting</span> <span class="o">=</span> <span class="n">reference_sorting</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">new_sorting</span><span class="p">[</span><span class="n">perm</span><span class="p">[</span><span class="n">k</span><span class="p">],</span> <span class="p">:]</span> <span class="o">=</span> <span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">][</span><span class="n">k</span><span class="p">]</span>
<span class="n">current_score</span> <span class="o">*=</span> <span class="nb">abs</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">det</span><span class="p">(</span><span class="n">new_sorting</span><span class="p">))</span>
<span class="k">if</span> <span class="n">current_score</span> <span class="o">&gt;</span> <span class="n">best_score</span><span class="p">:</span>
<span class="n">best_score</span> <span class="o">=</span> <span class="n">current_score</span>
<span class="n">best_perm</span> <span class="o">=</span> <span class="n">perm</span>
<span class="c1"># print(&quot;best perm&quot;, best_perm)</span>
<span class="n">sorted_vec_set</span><span class="o">.</span><span class="n">append</span><span class="p">([</span><span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">best_perm</span><span class="p">])</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sorted_vec_set</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">vec_set</span><span class="p">[</span><span class="n">t</span><span class="p">])</span>
<span class="k">return</span> <span class="n">sorted_vec_set</span>
</pre></div>
</details>
</section>
<section id="permutation">
<div class="attr function"><a class="headerlink" href="#permutation">#&nbsp;&nbsp</a>
@ -3723,28 +3704,6 @@ specifies a custom path for the file (default '.')</li>
</section>
<section id="GEVP_solver">
<div class="attr function"><a class="headerlink" href="#GEVP_solver">#&nbsp;&nbsp</a>
<span class="def">def</span>
<span class="name">GEVP_solver</span><span class="signature">(Gt, G0)</span>:
</div>
<details>
<summary>View Source</summary>
<div class="codehilite"><pre><span></span><span class="k">def</span> <span class="nf">GEVP_solver</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">):</span> <span class="c1"># Just so normalization an sorting does not need to be repeated. Here we could later put in some checks</span>
<span class="n">sp_val</span><span class="p">,</span> <span class="n">sp_vecs</span> <span class="o">=</span> <span class="n">scipy</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">eig</span><span class="p">(</span><span class="n">Gt</span><span class="p">,</span> <span class="n">G0</span><span class="p">)</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">sp_vecs</span><span class="p">[:,</span> <span class="n">np</span><span class="o">.</span><span class="n">argsort</span><span class="p">(</span><span class="n">sp_val</span><span class="p">)[</span><span class="o">-</span><span class="n">i</span><span class="p">]]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">sp_vecs</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)]</span>
<span class="n">sp_vecs</span> <span class="o">=</span> <span class="p">[</span><span class="n">v</span> <span class="o">/</span> <span class="n">np</span><span class="o">.</span><span class="n">sqrt</span><span class="p">((</span><span class="n">v</span><span class="o">.</span><span class="n">T</span> <span class="o">@</span> <span class="n">G0</span> <span class="o">@</span> <span class="n">v</span><span class="p">))</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">sp_vecs</span><span class="p">]</span>
<span class="k">return</span> <span class="n">sp_vecs</span>
</pre></div>
</details>
</section>
</main>
<script>

2
docs/search.js
View file

File diff suppressed because one or more lines are too long