Fix some platform dependent test failures

Author: jdjakem

.github/workflows/continuous-integration-workflow-conda.yml

@@ -23,7 +23,8 @@ jobs:
         # os: [ubuntu-latest]
         # pin to python-3.7.16 because github actions has a bug with _bz2 on
         # ubunutu for 3.7.17
-        python-version: [3.7.16, 3.8, 3.9, 3.10, 3.11]
+	# quotes needed around two-digit versions
+        python-version: [3.8, 3.9, '3.10', '3.11']
         os: [ubuntu-latest, macos-latest]
         # python-version: [3.7, 3.8] #3.8 currently fails due to numpy error
         # solely experienced when using github actions ValueError:

.github/workflows/continuous-integration-workflow-docs.yml

@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         # os: [ubuntu-latest]
-        python-version: [3.7]
+        python-version: [3.8, 3.9, '3.10', '3.11']
         os: [ubuntu-latest, macos-latest]
         # python-version: [3.7, 3.8] #3.8 currently fails due to numpy error
         # solely experienced when using github actions ValueError:

.github/workflows/continuous-integration-workflow-pip.yml

@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, ubuntu-latest]
-        python-version: [3.7.16, 3.8, 3.9, 3.10, 3.11]
+        python-version: [3.8, 3.9, '3.10', '3.11']
         # exclude:
         #  # stalls on github actions
         #  - os: ubuntu-latest

pyapprox/benchmarks/tests/test_benchmarks.py

@@ -24,7 +24,7 @@ def test_ishigami_function_gradient_and_hessian(self):
         errors = check_gradients(
             benchmark.fun, benchmark.jac, init_guess, disp=False)
         # print(errors.min())
-        assert errors.min() < 2e-6
+        assert errors.min() < 7e-6
         def hess_matvec(x, v): return np.dot(benchmark.hess(x), v)
         errors = check_hessian(
             benchmark.jac, hess_matvec, init_guess, disp=False)
@@ -104,7 +104,7 @@ def test_wing_weight_gradient(self):
         sample = variable.rvs(1)
         errors = check_gradients(fun, grad, sample)
         errors = errors[np.isfinite(errors)]
-        assert errors.max() > 0.1 and errors.min() <= 6e-7
+        assert errors.max() > 0.1 and errors.min() <= 7e-7
 
     def test_random_oscillator_analytical_solution(self):
         benchmark = setup_benchmark("random_oscillator")

pyapprox/multifidelity/tests/test_mfnets.py

@@ -415,7 +415,7 @@ def _check_least_squares_optimization(self, ninputs, nmodels,
         true_params = np.random.normal(0, 1, (true_mfnets.get_nparams(), 1))
         true_mfnets.set_parameters(true_params)
         nnodes = true_mfnets.get_nnodes()
-        print(true_params, 'pp')
+        # print(true_params, 'pp')
 
         ntrain_samples_list = [ndiscrepancy_params+nscaling_params+1]*nnodes
         train_samples_list = [
@@ -425,7 +425,7 @@ def _check_least_squares_optimization(self, ninputs, nmodels,
         noise_std_list = [1]*nnodes
         init_params = np.random.normal(0, 1, true_params.shape)
         mfnets = MFNets(copy.deepcopy(true_graph))
-        print(train_samples_list, train_values_list)
+        # print(train_samples_list, train_values_list)
 
         node_id_list = np.arange(1, mfnets.get_nnodes()+1)
 
@@ -439,13 +439,13 @@ def objective_wrapper(pp):
             result = mfnets.fit_objective(pp)
             return result[0], result[1].T
 
-        print((np.zeros(true_mfnets.get_nparams()),
-               objective_wrapper(true_params)))
+        # print((np.zeros(true_mfnets.get_nparams()),
+        #        objective_wrapper(true_params)))
         assert np.allclose(np.zeros(true_mfnets.get_nparams()),
                            objective_wrapper(true_params)[1])
 
         diffs = check_gradients(objective_wrapper, True, init_params)
-        assert diffs.min()/diffs.max() < 2e-6
+        assert diffs.min()/diffs.max() < 3e-6
 
         tol = 1e-10
         # opts = {'disp': True, "iprint": 3, "gtol": tol, "ftol": tol,

pyapprox/pde/autopde/physics.py

@@ -134,18 +134,27 @@ def _linear_solve(self, jac, res):
         if self._islinear:
             if self._linear_jac_factors is None:
                 # this line does not work with pickle
-                #self._linear_jac_factors = torch.linalg.qr(jac, mode="complete")
+                # self._linear_jac_factors = torch.linalg.qr(
+                #     jac, mode="complete")
                 # so use these three lines
                 import numpy as np
-                self._linear_jac_factors = np.linalg.qr(jac.numpy(), mode="complete")
-                self._linear_jac_factors = [torch.as_tensor(f, dtype=torch.double) for f in self._linear_jac_factors]
+                self._linear_jac_factors = np.linalg.qr(
+                    jac.numpy(), mode="complete")
+                self._linear_jac_factors = [
+                    torch.as_tensor(f, dtype=torch.double)
+                    for f in self._linear_jac_factors]
             # print((torch.linalg.multi_dot(self._linear_jac_factors)))
             # print(jac)
             # print((torch.linalg.multi_dot(self._linear_jac_factors))-jac)
-            # assert torch.allclose(torch.linalg.multi_dot(self._linear_jac_factors), jac)
-
-            tmp = torch.linalg.multi_dot((self._linear_jac_factors[0].T, res))[:, None]
-            return torch.triangular_solve(tmp, self._linear_jac_factors[1], upper=True)[0][:, 0]
+            # assert torch.allclose(
+            #     torch.linalg.multi_dot(self._linear_jac_factors), jac)
+
+            tmp = torch.linalg.multi_dot(
+                (self._linear_jac_factors[0].T, res))[:, None]
+            # return torch.triangular_solve(
+            #     tmp, self._linear_jac_factors[1], upper=True)[0][:, 0]
+            return torch.linalg.solve_triangular(
+                self._linear_jac_factors[1], tmp, upper=True)[:, 0]
         return super()._linear_solve(jac, res)
 
     def _clear_data(self):

pyapprox/pde/autopde/tests/test_autopde.py

@@ -41,8 +41,8 @@
 # Functions and testing only for wrapping Sympy generated manufactured
 # solutions
 def _normal_flux(flux_funs, normal_fun, xx):
-    normal_vals = torch.as_tensor(normal_fun(xx))
-    flux_vals = torch.as_tensor(flux_funs(xx))
+    normal_vals = torch.as_tensor(normal_fun(xx), dtype=torch.double)
+    flux_vals = torch.as_tensor(flux_funs(xx), dtype=torch.double)
     vals = torch.sum(normal_vals*flux_vals, dim=1)[:, None]
     return vals
 
@@ -293,7 +293,8 @@ def set_param_values(residual, param_vals):
 
         def fun(params):
             set_param_values(
-                fwd_solver.physics, torch.as_tensor(params[:, 0]))
+                fwd_solver.physics,
+                torch.as_tensor(params[:, 0], dtype=torch.double))
             # newton tol must be smaller than finite difference step size
             fd_sol = fwd_solver.solve(tol=1e-8, verbosity=0, rtol=1e-12)
             qoi = np.asarray([functional(fd_sol, params[:, 0])])
@@ -330,7 +331,8 @@ def fun(params):
 
         errors = check_gradients(
             fun, lambda p: adj_solver.compute_gradient(
-                set_param_values, torch.as_tensor(p)[:, 0]).numpy(),
+                set_param_values,
+                torch.as_tensor(p, dtype=torch.double)[:, 0]).numpy(),
             param_vals.numpy()[:, None], plot=False,
             fd_eps=3*np.logspace(-13, 0, 14)[::-1],
             direction=np.array([1])[:, None])
@@ -463,11 +465,11 @@ def fun(params, return_grad=True):
             if return_grad is False:
                 qoi = adj_solver.compute_qoi(
                     init_sol, 0, final_time, set_param_values,
-                    torch.as_tensor(params[:, 0]))[2]
+                    torch.as_tensor(params[:, 0], dtype=torch.double))[2]
                 return np.atleast_1d(qoi)
             qoi, grad = adj_solver.compute_gradient(
                 init_sol, 0, final_time, set_param_values,
-                torch.as_tensor(params[:, 0]))
+                torch.as_tensor(params[:, 0], dtype=torch.double))
             return qoi, grad
 
         # qoi, grad = adj_solver.compute_gradient(
@@ -697,10 +699,11 @@ def _check_stokes_solver_mms(
             solver.physics._residual(exact_sol[:, 0])[0], 0, atol=2.2e-8)
 
         def fun(s):
-            return solver.physics._raw_residual(torch.as_tensor(s))[0].numpy()
+            return solver.physics._raw_residual(
+                torch.as_tensor(s, dtype=torch.double))[0].numpy()
         j_fd = approx_jacobian(fun, exact_sol[:, 0].numpy())
         j_man = solver.physics._raw_residual(
-            torch.as_tensor(exact_sol[:, 0]))[1].numpy()
+            torch.as_tensor(exact_sol[:, 0], dtype=torch.double))[1].numpy()
         j_auto = torch.autograd.functional.jacobian(
             lambda s: solver.physics._raw_residual(s)[0],
             exact_sol[:, 0].clone().requires_grad_(True), strict=True).numpy()
@@ -795,7 +798,8 @@ def _check_shallow_ice_solver_mms(
         # print(np.abs(solver.physics._raw_residual(exact_sol[:, 0])))
 
         def fun(s):
-            return solver.physics._raw_residual(torch.as_tensor(s))[0].numpy()
+            return solver.physics._raw_residual(
+                torch.as_tensor(s, dtype=torch.double))[0].numpy()
         j_fd = approx_jacobian(fun, exact_sol[:, 0].numpy())
         # j_man = solver.physics._raw_residual(torch.as_tensor(exact_sol[:, 0]))[1].numpy()
         j_auto = torch.autograd.functional.jacobian(

pyapprox/pde/hdg/tests/test_pde_coupling.py

@@ -538,9 +538,9 @@ def _check_transient_advection_diffusion_reaction(
                  for model in domain_decomp._subdomain_models])
         subdomain_sols, times = decomp_solver.solve(
             init_sols, 0, final_time, deltat, verbosity=0,
-            subdomain_newton_kwargs={"verbosity": 0, "tol": 1e-8, "rtol": 1e-9,
+            subdomain_newton_kwargs={"verbosity": 0, "tol": 1e-8, "rtol": 1e-8,
                                      "maxiters": maxiters},
-            macro_newton_kwargs={"verbosity": 0, "tol": 1e-8, "rtol": 1e-9,
+            macro_newton_kwargs={"verbosity": 0, "tol": 1e-8, "rtol": 1e-8,
                                  "maxiters": maxiters})
         for ii, time in enumerate(times):
             sol_fun.set_time(time)

pyapprox/surrogates/gaussianprocess/tests/test_gaussian_process.py

@@ -920,7 +920,7 @@ def func(x):
             {'basis_type': 'hyperbolic_cross', 'variable': variable,
              'options': {'max_degree': 4}}).approx
         assert np.linalg.norm(validation_vals - pce(validation_samples)) / \
-            np.linalg.norm(validation_vals) < 1e-15
+            np.linalg.norm(validation_vals) < 3e-15
 
         pce_interaction_terms, pce_sobol_indices = get_sobol_indices(
             pce.get_coefficients(), pce.get_indices(), max_order=3)

pytest.ini

@@ -1,3 +1,4 @@
 [pytest]
 addopts = --ignore-glob=pyapprox_dev
-filterwarnings = ignore:::sklearn.*:
+# filterwarnings = ignore:::sklearn.*:
+filterwarnings = ignore::::