Xmipp  v3.23.11-Nereus
Classes | Typedefs | Functions | Variables
numerical_tools.h File Reference
#include "core/multidim_array.h"
Include dependency graph for numerical_tools.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  GaussianInterpolator
 
class  DESolver
 

Typedefs

typedef void(DESolver::* StrategyFunction) (int)
 

Functions

void randomPermutation (int N, MultidimArray< int > &result)
 
void powellOptimizer (Matrix1D< double > &p, int i0, int n, double(*f)(double *, void *), void *prm, double ftol, double &fret, int &iter, const Matrix1D< double > &steps, bool show=false)
 
double solveNonNegative (const Matrix2D< double > &A, const Matrix1D< double > &b, Matrix1D< double > &result)
 
void solveViaCholesky (const Matrix2D< double > &A, const Matrix1D< double > &b, Matrix1D< double > &result)
 
void evaluateQuadratic (const Matrix1D< double > &x, const Matrix1D< double > &c, const Matrix2D< double > &H, double &val, Matrix1D< double > &grad)
 
void quadraticProgramming (const Matrix2D< double > &C, const Matrix1D< double > &d, const Matrix2D< double > &A, const Matrix1D< double > &b, const Matrix2D< double > &Aeq, const Matrix1D< double > &beq, Matrix1D< double > &bl, Matrix1D< double > &bu, Matrix1D< double > &x)
 
void leastSquare (const Matrix2D< double > &C, const Matrix1D< double > &d, const Matrix2D< double > &A, const Matrix1D< double > &b, const Matrix2D< double > &Aeq, const Matrix1D< double > &beq, Matrix1D< double > &bl, Matrix1D< double > &bu, Matrix1D< double > &x)
 
void regularizedLeastSquare (const Matrix2D< double > &A, const Matrix1D< double > &d, double lambda, const Matrix2D< double > &G, Matrix1D< double > &x)
 
template<typename T >
void solve (const Matrix2D< T > &A, const Matrix1D< T > &b, Matrix1D< T > &result)
 
template<typename T >
void solveBySVD (const Matrix2D< T > &A, const Matrix1D< T > &b, Matrix1D< double > &result, double tolerance)
 
template<typename T >
void solve (const Matrix2D< T > &A, const Matrix2D< T > &b, Matrix2D< T > &result)
 
double checkRandomness (const std::string &sequence)
 
double ZernikeSphericalHarmonics (int l1, int n, int l2, int m, double xr, double yr, double zr, double r)
 
void spherical_index2lnm (int idx, int &l1, int &n, int &l2, int &m, int maxl1)
 
int spherical_lnm2index (int l1, int n, int l2, int m, int maxl1)
 

Variables

constexpr int stBest1Exp = 0
 
constexpr int stRand1Exp = 1
 
constexpr int stRandToBest1Exp = 2
 
constexpr int stBest2Exp = 3
 
constexpr int stRand2Exp = 4
 
constexpr int stBest1Bin = 5
 
constexpr int stRand1Bin = 6
 
constexpr int stRandToBest1Bin = 7
 
constexpr int stBest2Bin = 8
 
constexpr int stRand2Bin = 9
 

Typedef Documentation

◆ StrategyFunction

typedef void(DESolver::* StrategyFunction) (int)

Definition at line 275 of file numerical_tools.h.

Function Documentation

◆ checkRandomness()

double checkRandomness ( const std::string &  sequence)

Check the randomness of a sequence. The function returns a z-score of randomness. The highest the Z-score in absolute value, the less random the sequence is. The sequence is supposed to be formed by two symbols:

  • and -, 0 and 1, A and B, ...

Definition at line 806 of file numerical_tools.cpp.

807 {
808  int imax=sequence.size();
809  if (imax<=1)
810  return 0;
811  double n0=1;
812  double n1=0;
813  double R=1;
814  int current=0;
815  for (int i=1; i<imax; ++i)
816  {
817  if (sequence[i]!=sequence[i-1])
818  {
819  current=(current+1)%2;
820  R++;
821  if (current==0)
822  n0++;
823  else
824  n1++;
825  }
826  else
827  {
828  if (current==0)
829  n0++;
830  else
831  n1++;
832  }
833  }
834  double m=1+2*n0*n1/(n0+n1);
835  double s=sqrt(2*n0*n1*(2*n0*n1-n0-n1)/((n0+n1)*(n0+n1)*(n0+n1-1)));
836  double z=(R-m)/s;
837  return ABS(z);
838 }
void sqrt(Image< double > &op)
#define i
#define ABS(x)
Definition: xmipp_macros.h:142
double z
int m

◆ spherical_index2lnm()

void spherical_index2lnm ( int  idx,
int &  l1,
int &  n,
int &  l2,
int &  m,
int  maxl1 
)

Index to Spherical harmonics index. Given an integer consecutive index (0,1,2,3,...) this function returns the corresponding (n,l,m) for the spherical harmonics basis.

Definition at line 2159 of file numerical_tools.cpp.

2160 {
2161  auto numR = static_cast<int>(std::floor((4+4*max_l1+std::pow(max_l1,2))/4));
2162  double aux_id = std::floor(idx-(idx/numR)*numR);
2163  l1 = static_cast<int>(std::floor((1.0+std::sqrt(1.0+4.0*aux_id))/2.0) + std::floor((2.0+2.0*std::sqrt(aux_id))/2.0) - 2.0);
2164  n = static_cast<int>(std::ceil((4.0*aux_id - l1*(l1+2.0))/2.0));
2165  l2 = static_cast<int>(std::floor(std::sqrt(std::floor(idx/numR))));
2166  m = static_cast<int>(std::floor(idx/numR)-l2*(l2+1));
2167 }
__host__ __device__ float2 floor(const float2 v)
void sqrt(Image< double > &op)
int m
int * n

◆ spherical_lnm2index()

int spherical_lnm2index ( int  l1,
int  n,
int  l2,
int  m,
int  maxl1 
)

Index to Spherical harmonics index. Given the corresponding (n,l,m), this function returns an integer consecutive index (0,1,2,3,...) for the spherical harmonics basis.

Definition at line 2169 of file numerical_tools.cpp.

2170 {
2171  auto numR = static_cast<int>(std::floor((4+4*max_l1+std::pow(max_l1,2))/4));
2172  int id_SH = l2*(l2+1)+m;
2173  auto id_R = static_cast<int>(std::floor((2*n + l1*(l1 + 2))/4));
2174  int id_Z = id_SH*numR+id_R;
2175  return id_Z;
2176 }
__host__ __device__ float2 floor(const float2 v)
int m
int * n

◆ ZernikeSphericalHarmonics()

double ZernikeSphericalHarmonics ( int  l1,
int  n,
int  l2,
int  m,
double  xr,
double  yr,
double  zr,
double  r 
)

Spherical harmonics. This function calculates R_l^n(r)Y_l^m(xr,yr,zr) where R_l^n is the Zernike polynomial, l is the degree and n goes over odd or even values depending on the value of l. For instance, l=0 (n=0), l=1 (n=1), l=2 (n=0,2), l=3 (n=1,3), l=4 (n=0,2,4), ... The Y_l^m is the real spherical harmonic. l is the degree, and m=-l,...,l. For the specific formulas see https://en.wikipedia.org/wiki/Zernike_polynomials#Radial_polynomials and https://en.wikipedia.org/wiki/Table_of_spherical_harmonics#Real_spherical_harmonics. The cartesian coordinates xr, yr and zr are supposed to be normalized between -1 and 1, that is, xr=x/r, yr=y/r, and zr=z/r. r is supposed to be between 0 and 1.

Definition at line 1705 of file numerical_tools.cpp.

1705  {
1706  switch (l1) {
1707  case 0 : {
1708  switch (l2) {
1709  case 0: return ZernikeSphericalHarmonics<0, 0>(n, m, xr, yr, zr, r);
1710  case 1: return ZernikeSphericalHarmonics<0, 1>(n, m, xr, yr, zr, r);
1711  case 2: return ZernikeSphericalHarmonics<0, 2>(n, m, xr, yr, zr, r);
1712  case 3: return ZernikeSphericalHarmonics<0, 3>(n, m, xr, yr, zr, r);
1713  case 4: return ZernikeSphericalHarmonics<0, 4>(n, m, xr, yr, zr, r);
1714  case 5: return ZernikeSphericalHarmonics<0, 5>(n, m, xr, yr, zr, r);
1715  case 6: return ZernikeSphericalHarmonics<0, 6>(n, m, xr, yr, zr, r);
1716  case 7: return ZernikeSphericalHarmonics<0, 7>(n, m, xr, yr, zr, r);
1717  case 8: return ZernikeSphericalHarmonics<0, 8>(n, m, xr, yr, zr, r);
1718  case 9: return ZernikeSphericalHarmonics<0, 9>(n, m, xr, yr, zr, r);
1719  default: break;
1720  }
1721  } break;
1722  case 1 : {
1723  switch (l2) {
1724  case 0: return ZernikeSphericalHarmonics<1, 0>(n, m, xr, yr, zr, r);
1725  case 1: return ZernikeSphericalHarmonics<1, 1>(n, m, xr, yr, zr, r);
1726  case 2: return ZernikeSphericalHarmonics<1, 2>(n, m, xr, yr, zr, r);
1727  case 3: return ZernikeSphericalHarmonics<1, 3>(n, m, xr, yr, zr, r);
1728  case 4: return ZernikeSphericalHarmonics<1, 4>(n, m, xr, yr, zr, r);
1729  case 5: return ZernikeSphericalHarmonics<1, 5>(n, m, xr, yr, zr, r);
1730  case 6: return ZernikeSphericalHarmonics<1, 6>(n, m, xr, yr, zr, r);
1731  case 7: return ZernikeSphericalHarmonics<1, 7>(n, m, xr, yr, zr, r);
1732  case 8: return ZernikeSphericalHarmonics<1, 8>(n, m, xr, yr, zr, r);
1733  case 9: return ZernikeSphericalHarmonics<1, 9>(n, m, xr, yr, zr, r);
1734  default: break;
1735  }
1736  } break;
1737  case 2 : {
1738  switch (l2) {
1739  case 0: return ZernikeSphericalHarmonics<2, 0>(n, m, xr, yr, zr, r);
1740  case 1: return ZernikeSphericalHarmonics<2, 1>(n, m, xr, yr, zr, r);
1741  case 2: return ZernikeSphericalHarmonics<2, 2>(n, m, xr, yr, zr, r);
1742  case 3: return ZernikeSphericalHarmonics<2, 3>(n, m, xr, yr, zr, r);
1743  case 4: return ZernikeSphericalHarmonics<2, 4>(n, m, xr, yr, zr, r);
1744  case 5: return ZernikeSphericalHarmonics<2, 5>(n, m, xr, yr, zr, r);
1745  case 6: return ZernikeSphericalHarmonics<2, 6>(n, m, xr, yr, zr, r);
1746  case 7: return ZernikeSphericalHarmonics<2, 7>(n, m, xr, yr, zr, r);
1747  case 8: return ZernikeSphericalHarmonics<2, 8>(n, m, xr, yr, zr, r);
1748  case 9: return ZernikeSphericalHarmonics<2, 9>(n, m, xr, yr, zr, r);
1749  default: break;
1750  }
1751  } break;
1752  case 3 : {
1753  switch (l2) {
1754  case 0: return ZernikeSphericalHarmonics<3, 0>(n, m, xr, yr, zr, r);
1755  case 1: return ZernikeSphericalHarmonics<3, 1>(n, m, xr, yr, zr, r);
1756  case 2: return ZernikeSphericalHarmonics<3, 2>(n, m, xr, yr, zr, r);
1757  case 3: return ZernikeSphericalHarmonics<3, 3>(n, m, xr, yr, zr, r);
1758  case 4: return ZernikeSphericalHarmonics<3, 4>(n, m, xr, yr, zr, r);
1759  case 5: return ZernikeSphericalHarmonics<3, 5>(n, m, xr, yr, zr, r);
1760  case 6: return ZernikeSphericalHarmonics<3, 6>(n, m, xr, yr, zr, r);
1761  case 7: return ZernikeSphericalHarmonics<3, 7>(n, m, xr, yr, zr, r);
1762  case 8: return ZernikeSphericalHarmonics<3, 8>(n, m, xr, yr, zr, r);
1763  case 9: return ZernikeSphericalHarmonics<3, 9>(n, m, xr, yr, zr, r);
1764  default: break;
1765  }
1766  } break;
1767  case 4 : {
1768  switch (l2) {
1769  case 0: return ZernikeSphericalHarmonics<4, 0>(n, m, xr, yr, zr, r);
1770  case 1: return ZernikeSphericalHarmonics<4, 1>(n, m, xr, yr, zr, r);
1771  case 2: return ZernikeSphericalHarmonics<4, 2>(n, m, xr, yr, zr, r);
1772  case 3: return ZernikeSphericalHarmonics<4, 3>(n, m, xr, yr, zr, r);
1773  case 4: return ZernikeSphericalHarmonics<4, 4>(n, m, xr, yr, zr, r);
1774  case 5: return ZernikeSphericalHarmonics<4, 5>(n, m, xr, yr, zr, r);
1775  case 6: return ZernikeSphericalHarmonics<4, 6>(n, m, xr, yr, zr, r);
1776  case 7: return ZernikeSphericalHarmonics<4, 7>(n, m, xr, yr, zr, r);
1777  case 8: return ZernikeSphericalHarmonics<4, 8>(n, m, xr, yr, zr, r);
1778  case 9: return ZernikeSphericalHarmonics<4, 9>(n, m, xr, yr, zr, r);
1779  default: break;
1780  }
1781  } break;
1782  case 5 : {
1783  switch (l2) {
1784  case 0: return ZernikeSphericalHarmonics<5, 0>(n, m, xr, yr, zr, r);
1785  case 1: return ZernikeSphericalHarmonics<5, 1>(n, m, xr, yr, zr, r);
1786  case 2: return ZernikeSphericalHarmonics<5, 2>(n, m, xr, yr, zr, r);
1787  case 3: return ZernikeSphericalHarmonics<5, 3>(n, m, xr, yr, zr, r);
1788  case 4: return ZernikeSphericalHarmonics<5, 4>(n, m, xr, yr, zr, r);
1789  case 5: return ZernikeSphericalHarmonics<5, 5>(n, m, xr, yr, zr, r);
1790  case 6: return ZernikeSphericalHarmonics<5, 6>(n, m, xr, yr, zr, r);
1791  case 7: return ZernikeSphericalHarmonics<5, 7>(n, m, xr, yr, zr, r);
1792  case 8: return ZernikeSphericalHarmonics<5, 8>(n, m, xr, yr, zr, r);
1793  case 9: return ZernikeSphericalHarmonics<5, 9>(n, m, xr, yr, zr, r);
1794  default: break;
1795  }
1796  } break;
1797  case 6 : {
1798  switch (l2) {
1799  case 0: return ZernikeSphericalHarmonics<6, 0>(n, m, xr, yr, zr, r);
1800  case 1: return ZernikeSphericalHarmonics<6, 1>(n, m, xr, yr, zr, r);
1801  case 2: return ZernikeSphericalHarmonics<6, 2>(n, m, xr, yr, zr, r);
1802  case 3: return ZernikeSphericalHarmonics<6, 3>(n, m, xr, yr, zr, r);
1803  case 4: return ZernikeSphericalHarmonics<6, 4>(n, m, xr, yr, zr, r);
1804  case 5: return ZernikeSphericalHarmonics<6, 5>(n, m, xr, yr, zr, r);
1805  case 6: return ZernikeSphericalHarmonics<6, 6>(n, m, xr, yr, zr, r);
1806  case 7: return ZernikeSphericalHarmonics<6, 7>(n, m, xr, yr, zr, r);
1807  case 8: return ZernikeSphericalHarmonics<6, 8>(n, m, xr, yr, zr, r);
1808  case 9: return ZernikeSphericalHarmonics<6, 9>(n, m, xr, yr, zr, r);
1809  default: break;
1810  }
1811  } break;
1812  case 7 : {
1813  switch (l2) {
1814  case 0: return ZernikeSphericalHarmonics<7, 0>(n, m, xr, yr, zr, r);
1815  case 1: return ZernikeSphericalHarmonics<7, 1>(n, m, xr, yr, zr, r);
1816  case 2: return ZernikeSphericalHarmonics<7, 2>(n, m, xr, yr, zr, r);
1817  case 3: return ZernikeSphericalHarmonics<7, 3>(n, m, xr, yr, zr, r);
1818  case 4: return ZernikeSphericalHarmonics<7, 4>(n, m, xr, yr, zr, r);
1819  case 5: return ZernikeSphericalHarmonics<7, 5>(n, m, xr, yr, zr, r);
1820  case 6: return ZernikeSphericalHarmonics<7, 6>(n, m, xr, yr, zr, r);
1821  case 7: return ZernikeSphericalHarmonics<7, 7>(n, m, xr, yr, zr, r);
1822  case 8: return ZernikeSphericalHarmonics<7, 8>(n, m, xr, yr, zr, r);
1823  case 9: return ZernikeSphericalHarmonics<7, 9>(n, m, xr, yr, zr, r);
1824  default: break;
1825  }
1826  } break;
1827  case 8 : {
1828  switch (l2) {
1829  case 0: return ZernikeSphericalHarmonics<8, 0>(n, m, xr, yr, zr, r);
1830  case 1: return ZernikeSphericalHarmonics<8, 1>(n, m, xr, yr, zr, r);
1831  case 2: return ZernikeSphericalHarmonics<8, 2>(n, m, xr, yr, zr, r);
1832  case 3: return ZernikeSphericalHarmonics<8, 3>(n, m, xr, yr, zr, r);
1833  case 4: return ZernikeSphericalHarmonics<8, 4>(n, m, xr, yr, zr, r);
1834  case 5: return ZernikeSphericalHarmonics<8, 5>(n, m, xr, yr, zr, r);
1835  case 6: return ZernikeSphericalHarmonics<8, 6>(n, m, xr, yr, zr, r);
1836  case 7: return ZernikeSphericalHarmonics<8, 7>(n, m, xr, yr, zr, r);
1837  case 8: return ZernikeSphericalHarmonics<8, 8>(n, m, xr, yr, zr, r);
1838  case 9: return ZernikeSphericalHarmonics<8, 9>(n, m, xr, yr, zr, r);
1839  default: break;
1840  }
1841  } break;
1842  case 9 : {
1843  switch (l2) {
1844  case 0: return ZernikeSphericalHarmonics<9, 0>(n, m, xr, yr, zr, r);
1845  case 1: return ZernikeSphericalHarmonics<9, 1>(n, m, xr, yr, zr, r);
1846  case 2: return ZernikeSphericalHarmonics<9, 2>(n, m, xr, yr, zr, r);
1847  case 3: return ZernikeSphericalHarmonics<9, 3>(n, m, xr, yr, zr, r);
1848  case 4: return ZernikeSphericalHarmonics<9, 4>(n, m, xr, yr, zr, r);
1849  case 5: return ZernikeSphericalHarmonics<9, 5>(n, m, xr, yr, zr, r);
1850  case 6: return ZernikeSphericalHarmonics<9, 6>(n, m, xr, yr, zr, r);
1851  case 7: return ZernikeSphericalHarmonics<9, 7>(n, m, xr, yr, zr, r);
1852  case 8: return ZernikeSphericalHarmonics<9, 8>(n, m, xr, yr, zr, r);
1853  case 9: return ZernikeSphericalHarmonics<9, 9>(n, m, xr, yr, zr, r);
1854  default: break;
1855  }
1856  } break;
1857  case 10 : {
1858  switch (l2) {
1859  case 0: return ZernikeSphericalHarmonics<10, 0>(n, m, xr, yr, zr, r);
1860  case 1: return ZernikeSphericalHarmonics<10, 1>(n, m, xr, yr, zr, r);
1861  case 2: return ZernikeSphericalHarmonics<10, 2>(n, m, xr, yr, zr, r);
1862  case 3: return ZernikeSphericalHarmonics<10, 3>(n, m, xr, yr, zr, r);
1863  case 4: return ZernikeSphericalHarmonics<10, 4>(n, m, xr, yr, zr, r);
1864  case 5: return ZernikeSphericalHarmonics<10, 5>(n, m, xr, yr, zr, r);
1865  case 6: return ZernikeSphericalHarmonics<10, 6>(n, m, xr, yr, zr, r);
1866  case 7: return ZernikeSphericalHarmonics<10, 7>(n, m, xr, yr, zr, r);
1867  case 8: return ZernikeSphericalHarmonics<10, 8>(n, m, xr, yr, zr, r);
1868  case 9: return ZernikeSphericalHarmonics<10, 9>(n, m, xr, yr, zr, r);
1869  default: break;
1870  }
1871  } break;
1872  case 11 : {
1873  switch (l2) {
1874  case 0: return ZernikeSphericalHarmonics<11, 0>(n, m, xr, yr, zr, r);
1875  case 1: return ZernikeSphericalHarmonics<11, 1>(n, m, xr, yr, zr, r);
1876  case 2: return ZernikeSphericalHarmonics<11, 2>(n, m, xr, yr, zr, r);
1877  case 3: return ZernikeSphericalHarmonics<11, 3>(n, m, xr, yr, zr, r);
1878  case 4: return ZernikeSphericalHarmonics<11, 4>(n, m, xr, yr, zr, r);
1879  case 5: return ZernikeSphericalHarmonics<11, 5>(n, m, xr, yr, zr, r);
1880  case 6: return ZernikeSphericalHarmonics<11, 6>(n, m, xr, yr, zr, r);
1881  case 7: return ZernikeSphericalHarmonics<11, 7>(n, m, xr, yr, zr, r);
1882  case 8: return ZernikeSphericalHarmonics<11, 8>(n, m, xr, yr, zr, r);
1883  case 9: return ZernikeSphericalHarmonics<11, 9>(n, m, xr, yr, zr, r);
1884  default: break;
1885  }
1886  } break;
1887  case 12 : {
1888  switch (l2) {
1889  case 0: return ZernikeSphericalHarmonics<12, 0>(n, m, xr, yr, zr, r);
1890  case 1: return ZernikeSphericalHarmonics<12, 1>(n, m, xr, yr, zr, r);
1891  case 2: return ZernikeSphericalHarmonics<12, 2>(n, m, xr, yr, zr, r);
1892  case 3: return ZernikeSphericalHarmonics<12, 3>(n, m, xr, yr, zr, r);
1893  case 4: return ZernikeSphericalHarmonics<12, 4>(n, m, xr, yr, zr, r);
1894  case 5: return ZernikeSphericalHarmonics<12, 5>(n, m, xr, yr, zr, r);
1895  case 6: return ZernikeSphericalHarmonics<12, 6>(n, m, xr, yr, zr, r);
1896  case 7: return ZernikeSphericalHarmonics<12, 7>(n, m, xr, yr, zr, r);
1897  case 8: return ZernikeSphericalHarmonics<12, 8>(n, m, xr, yr, zr, r);
1898  case 9: return ZernikeSphericalHarmonics<12, 9>(n, m, xr, yr, zr, r);
1899  default: break;
1900  }
1901  } break;
1902  case 13 : {
1903  switch (l2) {
1904  case 0: return ZernikeSphericalHarmonics<13, 0>(n, m, xr, yr, zr, r);
1905  case 1: return ZernikeSphericalHarmonics<13, 1>(n, m, xr, yr, zr, r);
1906  case 2: return ZernikeSphericalHarmonics<13, 2>(n, m, xr, yr, zr, r);
1907  case 3: return ZernikeSphericalHarmonics<13, 3>(n, m, xr, yr, zr, r);
1908  case 4: return ZernikeSphericalHarmonics<13, 4>(n, m, xr, yr, zr, r);
1909  case 5: return ZernikeSphericalHarmonics<13, 5>(n, m, xr, yr, zr, r);
1910  case 6: return ZernikeSphericalHarmonics<13, 6>(n, m, xr, yr, zr, r);
1911  case 7: return ZernikeSphericalHarmonics<13, 7>(n, m, xr, yr, zr, r);
1912  case 8: return ZernikeSphericalHarmonics<13, 8>(n, m, xr, yr, zr, r);
1913  case 9: return ZernikeSphericalHarmonics<13, 9>(n, m, xr, yr, zr, r);
1914  default: break;
1915  }
1916  } break;
1917  case 14 : {
1918  switch (l2) {
1919  case 0: return ZernikeSphericalHarmonics<14, 0>(n, m, xr, yr, zr, r);
1920  case 1: return ZernikeSphericalHarmonics<14, 1>(n, m, xr, yr, zr, r);
1921  case 2: return ZernikeSphericalHarmonics<14, 2>(n, m, xr, yr, zr, r);
1922  case 3: return ZernikeSphericalHarmonics<14, 3>(n, m, xr, yr, zr, r);
1923  case 4: return ZernikeSphericalHarmonics<14, 4>(n, m, xr, yr, zr, r);
1924  case 5: return ZernikeSphericalHarmonics<14, 5>(n, m, xr, yr, zr, r);
1925  case 6: return ZernikeSphericalHarmonics<14, 6>(n, m, xr, yr, zr, r);
1926  case 7: return ZernikeSphericalHarmonics<14, 7>(n, m, xr, yr, zr, r);
1927  case 8: return ZernikeSphericalHarmonics<14, 8>(n, m, xr, yr, zr, r);
1928  case 9: return ZernikeSphericalHarmonics<14, 9>(n, m, xr, yr, zr, r);
1929  default: break;
1930  }
1931  } break;
1932  case 15 : {
1933  switch (l2) {
1934  case 0: return ZernikeSphericalHarmonics<15, 0>(n, m, xr, yr, zr, r);
1935  case 1: return ZernikeSphericalHarmonics<15, 1>(n, m, xr, yr, zr, r);
1936  case 2: return ZernikeSphericalHarmonics<15, 2>(n, m, xr, yr, zr, r);
1937  case 3: return ZernikeSphericalHarmonics<15, 3>(n, m, xr, yr, zr, r);
1938  case 4: return ZernikeSphericalHarmonics<15, 4>(n, m, xr, yr, zr, r);
1939  case 5: return ZernikeSphericalHarmonics<15, 5>(n, m, xr, yr, zr, r);
1940  case 6: return ZernikeSphericalHarmonics<15, 6>(n, m, xr, yr, zr, r);
1941  case 7: return ZernikeSphericalHarmonics<15, 7>(n, m, xr, yr, zr, r);
1942  case 8: return ZernikeSphericalHarmonics<15, 8>(n, m, xr, yr, zr, r);
1943  case 9: return ZernikeSphericalHarmonics<15, 9>(n, m, xr, yr, zr, r);
1944  default: break;
1945  }
1946  } break;
1947  default: break;
1948  }
1949  REPORT_ERROR(ERR_ARG_INCORRECT, "ZernikeSphericalHarmonics not supported for l1 = " + std::to_string(l1) + " and l2 = " + std::to_string(l2));
1950 }
#define REPORT_ERROR(nerr, ErrormMsg)
Definition: xmipp_error.h:211
Incorrect argument received.
Definition: xmipp_error.h:113
int m
std::string to_string(bond_type bondType)
Definition: compound.cpp:43
int * n

Variable Documentation

◆ stBest1Bin

constexpr int stBest1Bin = 5

Definition at line 267 of file numerical_tools.h.

◆ stBest1Exp

constexpr int stBest1Exp = 0

Definition at line 262 of file numerical_tools.h.

◆ stBest2Bin

constexpr int stBest2Bin = 8

Definition at line 270 of file numerical_tools.h.

◆ stBest2Exp

constexpr int stBest2Exp = 3

Definition at line 265 of file numerical_tools.h.

◆ stRand1Bin

constexpr int stRand1Bin = 6

Definition at line 268 of file numerical_tools.h.

◆ stRand1Exp

constexpr int stRand1Exp = 1

Definition at line 263 of file numerical_tools.h.

◆ stRand2Bin

constexpr int stRand2Bin = 9

Definition at line 271 of file numerical_tools.h.

◆ stRand2Exp

constexpr int stRand2Exp = 4

Definition at line 266 of file numerical_tools.h.

◆ stRandToBest1Bin

constexpr int stRandToBest1Bin = 7

Definition at line 269 of file numerical_tools.h.

◆ stRandToBest1Exp

constexpr int stRandToBest1Exp = 2

Definition at line 264 of file numerical_tools.h.