fix numpy interp methods

Author: Jammy2211

autoarray/abstract_ndarray.py

@@ -84,7 +84,7 @@ def __init__(self, array, xp=np):
         except ValueError:
             pass
 
-        self.xp = xp
+        self._xp = xp
 
     def invert(self):
         new = self.copy()

autoarray/fit/fit_dataset.py

@@ -83,7 +83,7 @@ def chi_squared(self) -> float:
         """
         Returns the chi-squared terms of the model data's fit to an dataset, by summing the chi-squared-map.
         """
-        return fit_util.chi_squared_from(chi_squared_map=self.chi_squared_map.array, xp=self.xp)
+        return fit_util.chi_squared_from(chi_squared_map=self.chi_squared_map.array, xp=self._xp)
 
     @property
     def noise_normalization(self) -> float:
@@ -92,7 +92,7 @@ def noise_normalization(self) -> float:
 
         [Noise_Term] = sum(log(2*pi*[Noise]**2.0))
         """
-        return fit_util.noise_normalization_from(noise_map=self.noise_map.array, xp=self.xp)
+        return fit_util.noise_normalization_from(noise_map=self.noise_map.array, xp=self._xp)
 
     @property
     def log_likelihood(self) -> float:
@@ -146,7 +146,7 @@ def __init__(
         self.dataset = dataset
         self.use_mask_in_fit = use_mask_in_fit
         self.dataset_model = dataset_model or DatasetModel()
-        self.xp = xp
+        self._xp = xp
 
     @property
     def mask(self) -> Mask2D:
@@ -196,7 +196,7 @@ def residual_map(self) -> ty.DataLike:
 
         if self.use_mask_in_fit:
             return fit_util.residual_map_with_mask_from(
-                data=self.data, model_data=self.model_data, mask=self.mask, xp=self.xp
+                data=self.data, model_data=self.model_data, mask=self.mask, xp=self._xp
             )
         return super().residual_map
 
@@ -209,7 +209,7 @@ def normalized_residual_map(self) -> ty.DataLike:
         """
         if self.use_mask_in_fit:
             return fit_util.normalized_residual_map_with_mask_from(
-                residual_map=self.residual_map, noise_map=self.noise_map, mask=self.mask, xp=self.xp
+                residual_map=self.residual_map, noise_map=self.noise_map, mask=self.mask, xp=self._xp
             )
         return super().normalized_residual_map
 
@@ -222,7 +222,7 @@ def chi_squared_map(self) -> ty.DataLike:
         """
         if self.use_mask_in_fit:
             return fit_util.chi_squared_map_with_mask_from(
-                residual_map=self.residual_map, noise_map=self.noise_map, mask=self.mask, xp=self.xp
+                residual_map=self.residual_map, noise_map=self.noise_map, mask=self.mask, xp=self._xp
             )
         return super().chi_squared_map
 
@@ -243,7 +243,7 @@ def chi_squared(self) -> float:
 
         if self.use_mask_in_fit:
             return fit_util.chi_squared_with_mask_from(
-                chi_squared_map=self.chi_squared_map, mask=self.mask, xp=self.xp
+                chi_squared_map=self.chi_squared_map, mask=self.mask, xp=self._xp
             )
         return super().chi_squared
 
@@ -256,7 +256,7 @@ def noise_normalization(self) -> float:
         """
         if self.use_mask_in_fit:
             return fit_util.noise_normalization_with_mask_from(
-                noise_map=self.noise_map, mask=self.mask, xp=self.xp
+                noise_map=self.noise_map, mask=self.mask, xp=self._xp
             )
         return super().noise_normalization
 

autoarray/fit/fit_interferometer.py

@@ -1,5 +1,4 @@
 import numpy as np
-from typing import Dict, Optional
 
 from autoarray.dataset.interferometer.dataset import Interferometer
 
@@ -18,6 +17,7 @@ def __init__(
         dataset: Interferometer,
         dataset_model: DatasetModel = None,
         use_mask_in_fit: bool = False,
+        xp=np
     ):
         """
         Class to fit a masked interferometer dataset.
@@ -58,6 +58,7 @@ def __init__(
             dataset=dataset,
             dataset_model=dataset_model,
             use_mask_in_fit=use_mask_in_fit,
+            xp=xp
         )
 
     @property

autoarray/inversion/inversion/abstract.py

@@ -73,7 +73,7 @@ def __init__(
 
         self.preloads = preloads or Preloads()
 
-        self.xp = xp
+        self._xp = xp
 
 
 
@@ -285,7 +285,7 @@ def mapping_matrix(self) -> np.ndarray:
         If there are multiple linear objects, the mapping matrices are stacked such that their simultaneous linear
         equations are solved simultaneously. This property returns the stacked mapping matrix.
         """
-        return self.xp.hstack(
+        return self._xp.hstack(
             [linear_obj.mapping_matrix for linear_obj in self.linear_obj_list]
         )
 
@@ -304,7 +304,7 @@ def operated_mapping_matrix(self) -> np.ndarray:
         If there are multiple linear objects, the blurred mapping matrices are stacked such that their simultaneous
         linear equations are solved simultaneously.
         """
-        return self.xp.hstack(self.operated_mapping_matrix_list)
+        return self._xp.hstack(self.operated_mapping_matrix_list)
 
     @property
     def data_vector(self) -> np.ndarray:
@@ -331,7 +331,7 @@ def regularization_matrix(self) -> Optional[np.ndarray]:
         If the `settings.force_edge_pixels_to_zeros` is `True`, the edge pixels of each mapper in the inversion
         are regularized so high their value is forced to zero.
         """
-        if self.xp.__name__.startswith("jax"):
+        if self._xp.__name__.startswith("jax"):
             from jax.scipy.linalg import block_diag
             return block_diag(
                 *[linear_obj.regularization_matrix for linear_obj in self.linear_obj_list]
@@ -379,7 +379,7 @@ def curvature_reg_matrix(self) -> np.ndarray:
         if not self.has(cls=AbstractRegularization):
             return self.curvature_matrix
 
-        return self.xp.add(self.curvature_matrix, self.regularization_matrix)
+        return self._xp.add(self.curvature_matrix, self.regularization_matrix)
 
     @property
     def curvature_reg_matrix_reduced(self) -> Optional[np.ndarray]:
@@ -448,15 +448,15 @@ def reconstruction(self) -> np.ndarray:
                         data_vector=data_vector,
                         curvature_reg_matrix=curvature_reg_matrix,
                         settings=self.settings,
-                        xp=self.xp
+                        xp=self._xp
                     )
                 )
 
                 # Allocate full solution array
-                reconstruction = self.xp.zeros(self.data_vector.shape[0])
+                reconstruction = self._xp.zeros(self.data_vector.shape[0])
 
                 # Scatter the partial solution back to the full shape
-                if self.xp.__name__.startswith("jax"):
+                if self._xp.__name__.startswith("jax"):
                     reconstruction = reconstruction.at[ids_to_keep].set(
                         reconstruction_partial
                     )
@@ -471,13 +471,13 @@ def reconstruction(self) -> np.ndarray:
                     data_vector=self.data_vector,
                     curvature_reg_matrix=self.curvature_reg_matrix,
                     settings=self.settings,
-                    xp=self.xp
+                    xp=self._xp
                 )
 
         return inversion_util.reconstruction_positive_negative_from(
             data_vector=self.data_vector,
             curvature_reg_matrix=self.curvature_reg_matrix,
-            xp=self.xp
+            xp=self._xp
         )
 
     @property
@@ -638,9 +638,9 @@ def regularization_term(self) -> float:
         if not self.has(cls=AbstractRegularization):
             return 0.0
 
-        return self.xp.matmul(
+        return self._xp.matmul(
             self.reconstruction_reduced.T,
-            self.xp.matmul(self.regularization_matrix_reduced, self.reconstruction_reduced),
+            self._xp.matmul(self.regularization_matrix_reduced, self.reconstruction_reduced),
         )
 
     @property
@@ -653,8 +653,8 @@ def log_det_curvature_reg_matrix_term(self) -> float:
         if not self.has(cls=AbstractRegularization):
             return 0.0
 
-        return 2.0 * self.xp.sum(
-            self.xp.log(self.xp.diag(self.xp.linalg.cholesky(self.curvature_reg_matrix_reduced)))
+        return 2.0 * self._xp.sum(
+            self._xp.log(self._xp.diag(self._xp.linalg.cholesky(self.curvature_reg_matrix_reduced)))
         )
 
     @property
@@ -674,8 +674,8 @@ def log_det_regularization_matrix_term(self) -> float:
         if not self.has(cls=AbstractRegularization):
             return 0.0
 
-        return 2.0 * self.xp.sum(
-            self.xp.log(self.xp.diag(self.xp.linalg.cholesky(self.regularization_matrix_reduced)))
+        return 2.0 * self._xp.sum(
+            self._xp.log(self._xp.diag(self._xp.linalg.cholesky(self.regularization_matrix_reduced)))
         )
 
     @property
@@ -738,7 +738,7 @@ def regularization_weights_from(self, index: int) -> np.ndarray:
 
             return np.zeros((pixels,))
 
-        return regularization.regularization_weights_from(linear_obj=linear_obj, xp=self.xp)
+        return regularization.regularization_weights_from(linear_obj=linear_obj, xp=self._xp)
 
     @property
     def regularization_weights_mapper_dict(self) -> Dict[LinearObj, np.ndarray]:

autoarray/inversion/inversion/imaging/abstract.py

@@ -93,7 +93,7 @@ def operated_mapping_matrix_list(self) -> List[np.ndarray]:
         return [
             (
                 self.psf.convolved_mapping_matrix_from(
-                    mapping_matrix=linear_obj.mapping_matrix, mask=self.mask, xp=self.xp
+                    mapping_matrix=linear_obj.mapping_matrix, mask=self.mask, xp=self._xp
                 )
                 if linear_obj.operated_mapping_matrix_override is None
                 else self.linear_func_operated_mapping_matrix_dict[linear_obj]
@@ -137,7 +137,7 @@ def linear_func_operated_mapping_matrix_dict(self) -> Dict:
                 operated_mapping_matrix = self.psf.convolved_mapping_matrix_from(
                     mapping_matrix=linear_func.mapping_matrix,
                     mask=self.mask,
-                    xp=self.xp
+                    xp=self._xp
                 )
 
             linear_func_operated_mapping_matrix_dict[linear_func] = (
@@ -219,7 +219,7 @@ def mapper_operated_mapping_matrix_dict(self) -> Dict:
             operated_mapping_matrix = self.psf.convolved_mapping_matrix_from(
                 mapping_matrix=mapper.mapping_matrix,
                 mask=self.mask,
-                xp=self.xp
+                xp=self._xp
             )
 
             mapper_operated_mapping_matrix_dict[mapper] = operated_mapping_matrix

autoarray/inversion/inversion/imaging/mapping.py

@@ -74,7 +74,7 @@ def _data_vector_mapper(self) -> np.ndarray:
             param_range = mapper_param_range_list[i]
 
             operated_mapping_matrix = self.psf.convolved_mapping_matrix_from(
-                mapping_matrix=mapper.mapping_matrix, mask=self.mask, xp=self.xp
+                mapping_matrix=mapper.mapping_matrix, mask=self.mask, xp=self._xp
             )
 
             data_vector_mapper = (
@@ -133,7 +133,7 @@ def _curvature_matrix_mapper_diag(self) -> Optional[np.ndarray]:
             mapper_param_range_i = mapper_param_range_list[i]
 
             operated_mapping_matrix = self.psf.convolved_mapping_matrix_from(
-                mapping_matrix=mapper_i.mapping_matrix, mask=self.mask, xp=self.xp
+                mapping_matrix=mapper_i.mapping_matrix, mask=self.mask, xp=self._xp
             )
 
             diag = inversion_util.curvature_matrix_via_mapping_matrix_from(
@@ -142,7 +142,7 @@ def _curvature_matrix_mapper_diag(self) -> Optional[np.ndarray]:
                 settings=self.settings,
                 add_to_curvature_diag=True,
                 no_regularization_index_list=self.no_regularization_index_list,
-                xp=self.xp
+                xp=self._xp
             )
 
             curvature_matrix[
@@ -151,7 +151,7 @@ def _curvature_matrix_mapper_diag(self) -> Optional[np.ndarray]:
             ] = diag
 
         curvature_matrix = inversion_util.curvature_matrix_mirrored_from(
-            curvature_matrix=curvature_matrix, xp=self.xp
+            curvature_matrix=curvature_matrix, xp=self._xp
         )
 
         return curvature_matrix
@@ -181,7 +181,7 @@ def curvature_matrix(self):
             settings=self.settings,
             add_to_curvature_diag=True,
             no_regularization_index_list=self.no_regularization_index_list,
-            xp=self.xp
+            xp=self._xp
         )
 
     @property
@@ -224,7 +224,7 @@ def mapped_reconstructed_data_dict(self) -> Dict[LinearObj, Array2D]:
                 inversion_util.mapped_reconstructed_data_via_mapping_matrix_from(
                     mapping_matrix=operated_mapping_matrix_list[index],
                     reconstruction=reconstruction,
-                    xp=self.xp
+                    xp=self._xp
                 )
             )
 

autoarray/inversion/inversion/imaging/w_tilde.py

@@ -524,7 +524,7 @@ def mapped_reconstructed_data_dict(self) -> Dict[LinearObj, Array2D]:
                 mapped_reconstructed_image = self.psf.convolved_image_from(
                     image=mapped_reconstructed_image,
                     blurring_image=None,
-                    xp=self.xp
+                    xp=self._xp
                 ).array
 
                 mapped_reconstructed_image = Array2D(

autoarray/inversion/inversion/interferometer/abstract.py

@@ -113,7 +113,7 @@ def mapped_reconstructed_image_dict(
                 inversion_util.mapped_reconstructed_data_via_mapping_matrix_from(
                     mapping_matrix=linear_obj.mapping_matrix,
                     reconstruction=reconstruction,
-                    xp=self.xp
+                    xp=self._xp
                 )
             )
 

autoarray/inversion/inversion/interferometer/mapping.py

@@ -91,23 +91,23 @@ def curvature_matrix(self) -> np.ndarray:
         real_curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from(
             mapping_matrix=self.operated_mapping_matrix.real,
             noise_map=self.noise_map.real,
-            xp=self.xp
+            xp=self._xp
         )
 
         imag_curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from(
             mapping_matrix=self.operated_mapping_matrix.imag,
             noise_map=self.noise_map.imag,
-            xp=self.xp
+            xp=self._xp
         )
 
-        curvature_matrix = self.xp.add(real_curvature_matrix, imag_curvature_matrix)
+        curvature_matrix = self._xp.add(real_curvature_matrix, imag_curvature_matrix)
 
         if len(self.no_regularization_index_list) > 0:
             curvature_matrix = inversion_util.curvature_matrix_with_added_to_diag_from(
                 curvature_matrix=curvature_matrix,
                 value=self.settings.no_regularization_add_to_curvature_diag_value,
                 no_regularization_index_list=self.no_regularization_index_list,
-                xp=self.xp
+                xp=self._xp
             )
 
         return curvature_matrix

autoarray/inversion/inversion/interferometer/w_tilde.py

@@ -122,7 +122,7 @@ def curvature_matrix_diag(self) -> np.ndarray:
 
         if self.settings.use_w_tilde_numpy:
             return inversion_util.curvature_matrix_via_w_tilde_from(
-                w_tilde=self.w_tilde.w_matrix, mapping_matrix=self.mapping_matrix, xp=self.xp
+                w_tilde=self.w_tilde.w_matrix, mapping_matrix=self.mapping_matrix, xp=self._xp
             )
 
         mapper = self.cls_list_from(cls=AbstractMapper)[0]