Merge pull request #336 from swift-nav/peddie-rtklib-fortran-order

RTKLIB routines use Fortran storage order.

Author: mookerji

python/swiftnav/lambda_.pyx

@@ -28,8 +28,8 @@ def lambda_reduction_(Q):
   """
   assert len(Q.shape) == 2 and Q.shape[0] == Q.shape[1], "Q matrix must have shape (n, n)"
   n = Q.shape[0]
-  cdef np.ndarray[np.double_t, ndim=2, mode="c"] Q_ = np.array(Q, dtype=np.double)
-  cdef np.ndarray[np.double_t, ndim=2, mode="c"] Z = np.empty((n, n), dtype=np.double)
+  cdef np.ndarray[np.double_t, ndim=2, mode="fortran"] Q_ = np.array(Q, dtype=np.double)
+  cdef np.ndarray[np.double_t, ndim=2, mode="fortran"] Z = np.empty((n, n), dtype=np.double)
   assert lambda_reduction(n, &Q_[0,0], &Z[0,0]) == 0, "lambda error!"
   return Z
 
@@ -51,9 +51,9 @@ def lambda_solution_(x, sigma, m):
   assert len(sigma.shape) == 2 and sigma.shape[0] == sigma.shape[1], "Q matrix must have shape (n, n)"
   assert len(x.shape) == 1 and x.shape[0] == sigma.shape[1], "x vector must have length to match sigma matrix"
   num_dds = x.shape[0]
-  cdef np.ndarray[np.double_t, ndim=1, mode="c"] x_ = np.array(x, dtype=np.double)
-  cdef np.ndarray[np.double_t, ndim=2, mode="c"] sigma_ = np.array(sigma, dtype=np.double)
-  cdef np.ndarray[np.double_t, ndim=2, mode="c"] F_ = np.empty((num_dds,m), dtype=np.double)
-  cdef np.ndarray[np.double_t, ndim=1, mode="c"] s_ = np.empty((m), dtype=np.double)
+  cdef np.ndarray[np.double_t, ndim=1, mode="fortran"] x_ = np.array(x, dtype=np.double)
+  cdef np.ndarray[np.double_t, ndim=2, mode="fortran"] sigma_ = np.array(sigma, dtype=np.double)
+  cdef np.ndarray[np.double_t, ndim=2, mode="fortran"] F_ = np.empty((num_dds,m), dtype=np.double, order='F')
+  cdef np.ndarray[np.double_t, ndim=1, mode="fortran"] s_ = np.empty((m), dtype=np.double, order='F')
   assert lambda_solution(num_dds, m, &x_[0], &sigma_[0,0], &F_[0,0], &s_[0]) == 0,"lambda error!"
   return (F_.T, s_.T)

python/tests/test_lambda.py

@@ -29,12 +29,12 @@ def test_lambda1():
                      [0.112202,   0.112202,   0.112202,   0.227134,   0.112202,   0.103473],
                      [0.112202,   0.112202,   0.112202,   0.112202,   0.227134,   0.103473],
                      [0.103473,   0.103473,   0.103473,   0.103473,   0.103473,   0.434339]])
-  F, s = l.lambda_solution_(x, sigma, m)
+  F, s = l.lambda_solution_(x, np.asfortranarray(sigma), m)
   assert np.allclose(F,
-                     np.array([[  1.58518400e+06,   3.91574300e+06,   9.56599100e+06,
-                                  1.58518400e+06,   3.91574300e+06,   9.56599100e+06],
-                               [ -6.71659900e+06,   7.62723400e+06,   9.89457273e+08,
-                                 -6.71660000e+06,   7.62723300e+06,   9.89457273e+08]]))
+                     np.array([[1.58518400e+06, -6.71659900e+06, 3.91574300e+06,
+                                7.62723400e+06, 9.56599100e+06, 9.89457273e+08],
+                               [1.58518400e+06, -6.71660000e+06, 3.91574300e+06,
+                                7.62723300e+06, 9.56599100e+06, 9.89457273e+08]]))
   assert np.allclose(s, np.array([ 3.50798444,  3.70845619]))
 
 def test_lambda2():
@@ -59,13 +59,37 @@ def test_lambda2():
                      [0.286388, 0.286388, 0.572775, 0.286388, 0.286388, 0.367531, 0.367531, 0.735063, 0.367531, 0.367531],
                      [0.286388, 0.286388, 0.286388, 0.572775, 0.286388, 0.367531, 0.367531, 0.367531, 0.735063, 0.367531],
                      [0.286388, 0.286388, 0.286388, 0.286388, 0.572775, 0.367531, 0.367531, 0.367531, 0.367531, 0.735063]])
-  F, s = l.lambda_solution_(x, sigma, m)
+  F, s = l.lambda_solution_(x, np.asfortranarray(sigma), m)
   assert np.allclose(F,
-                     [[-13324188., -7157236.00000014, -7454143.00000017,
-                       8336726.00000008, -17549108.00000054, -13324187.99999997,
-                       -7157236.00000013,  -7454143.00000013,   8336717.00000021,
-                       -17549108.00000053],
-                      [-10668900.99999994,  -6149379.00000041,  -5969220., 6186959.99999982,
-                       -13970171.00000022, -10668907.99999984,  -6149379.00000041,
-                       -5969219.99999996,   6186959.99999983, -13970171.00000017]])
+                     np.array([[-13324188., -10668900.99999994, -7157236.00000014,
+                                -6149379.00000041, -7454143.00000017, -5969220.,
+                                 8336726.00000008, 6186959.99999982, -17549108.00000054,
+                                -13970171.00000022],
+                               [-13324187.99999997, -10668907.99999984, -7157236.00000013,
+                                -6149379.00000041, -7454143.00000013, -5969219.99999996,
+                                 8336717.00000021, 6186959.99999983, -17549108.00000053,
+                                -13970171.00000017]]))
+
   assert np.allclose(s, np.array([ 1506.43579559,  1612.81177168]))
+
+def test_lambda3():
+  """
+  Verify that passing in perfectly decorrelated integers results in the
+  same integers being identified.
+  """
+  m = 1
+  x = np.array([-22, 22, -55, 55, -33, 33, -66, 66, -44, 44, -77, 77])
+  sigma = np.eye(x.size)
+  F, s = l.lambda_solution_(x, np.asfortranarray(sigma), m)
+  assert np.allclose(F[0], x)
+
+def test_lambda4():
+  """
+  Verify that the relative scale of the covariance matrix doesn't affect
+  the solution.
+  """
+  m = 1
+  x = np.array([-22, 22, -55, 55, -33, 33, -66, 66, -44, 44, -77, 77])
+  sigma = np.eye(x.size) * 1000
+  F, s = l.lambda_solution_(x, np.asfortranarray(sigma), m)
+  assert np.allclose(F[0], x)