Fix internal calls to avoid fortran warnings in tutorials

Author: ntjohnson1

pyttb/cp_apr.py

@@ -521,7 +521,9 @@ def tt_cp_apr_pdnr(  # noqa: PLR0912,PLR0913,PLR0915
             if isinstance(input_tensor, ttb.tensor) and isSparse is False:
                 # Data is not a sparse tensor.
                 Pi = tt_calcpi_prowsubprob(input_tensor, M, rank, n, N, isSparse)
-                X_mat = input_tensor.to_tenmat(np.array([n]), copy=False).data
+                X_mat = input_tensor.to_tenmat(
+                    np.array([n], order=input_tensor.order), copy=False
+                ).data
 
             num_rows = M.factor_matrices[n].shape[0]
             isRowNOTconverged = np.zeros((num_rows,))
@@ -876,7 +878,9 @@ def tt_cp_apr_pqnr(  # noqa: PLR0912,PLR0913,PLR0915
             if not isinstance(input_tensor, ttb.sptensor) and not isSparse:
                 # Data is not a sparse tensor.
                 Pi = tt_calcpi_prowsubprob(input_tensor, M, rank, n, N, isSparse)
-                X_mat = input_tensor.to_tenmat(np.array([n]), copy=False).data
+                X_mat = input_tensor.to_tenmat(
+                    np.array([n], order=input_tensor.order), copy=False
+                ).data
 
             num_rows = M.factor_matrices[n].shape[0]
             isRowNOTconverged = np.zeros((num_rows,))
@@ -1772,7 +1776,7 @@ def calculate_phi(  # noqa: PLR0913
             )
             Phi[:, r] = Yr
     else:
-        Xn = Data.to_tenmat(np.array([factorIndex]), copy=False).data
+        Xn = Data.to_tenmat(np.array([factorIndex], order=Data.order), copy=False).data
         V = Model.factor_matrices[factorIndex].dot(Pi.transpose())
         W = Xn / np.maximum(V, epsilon)
         Y = W.dot(Pi)
@@ -1817,8 +1821,8 @@ def tt_loglikelihood(
             np.sum(Data.vals * np.log(np.sum(A, axis=1))[:, None])
             - np.sum(Model.factor_matrices[0])
         )
-    dX = Data.to_tenmat(np.array([1]), copy=False).data
-    dM = Model.to_tenmat(np.array([1]), copy=False).data
+    dX = Data.to_tenmat(np.array([1], order=Data.order), copy=False).data
+    dM = Model.to_tenmat(np.array([1], order=Model.order), copy=False).data
     f = 0
     for i in range(dX.shape[0]):
         for j in range(dX.shape[1]):

pyttb/ktensor.py

@@ -74,7 +74,7 @@ class ktensor:
 
     __slots__ = ("weights", "factor_matrices")
 
-    def __init__(
+    def __init__(  # noqa: PLR0912
         self,
         factor_matrices: Optional[Sequence[np.ndarray]] = None,
         weights: Optional[np.ndarray] = None,
@@ -147,7 +147,7 @@ def __init__(
 
         # Empty constructor
         if factor_matrices is None and weights is None:
-            self.weights = np.array([])
+            self.weights = np.array([], order=self.order)
             self.factor_matrices: List[np.ndarray] = []
             return
 
@@ -183,12 +183,17 @@ def __init__(
             )
             # make copy or use reference
             if copy:
-                self.weights = weights.copy()
+                self.weights = weights.copy(self.order)
             else:
-                self.weights = weights
+                if not self._matches_order(weights):
+                    logging.warning(
+                        f"Selected no copy, but input data isn't {self.order} ordered "
+                        "so must copy."
+                    )
+                self.weights = np.asfortranarray(weights)
         else:
             # create weights if not provided
-            self.weights = np.ones(num_components)
+            self.weights = np.ones(num_components, order=self.order)
 
         # process factor_matrices
         if copy:
@@ -419,6 +424,14 @@ def order(self) -> Literal["F"]:
         """Return the data layout of the underlying storage."""
         return "F"
 
+    def _matches_order(self, array: np.ndarray) -> bool:
+        """Check if provided array matches tensor memory layout."""
+        if array.flags["C_CONTIGUOUS"] and self.order == "C":
+            return True
+        if array.flags["F_CONTIGUOUS"] and self.order == "F":
+            return True
+        return False
+
     def arrange(
         self,
         weight_factor: Optional[int] = None,
@@ -924,7 +937,9 @@ def min_split_dims(dims: Tuple[int, ...]):
         data = (
             ttb.khatrirao(*self.factor_matrices[:i_split], reverse=True) * self.weights
         ) @ ttb.khatrirao(*self.factor_matrices[i_split:], reverse=True).T
-        return ttb.tensor(data, self.shape, copy=False)
+        # Copy needed to ensure F order. Transpose above means both elements are
+        # different layout. If originally in C order can save on this copy.
+        return ttb.tensor(data, self.shape, copy=True)
 
     def to_tenmat(
         self,
@@ -1678,7 +1693,7 @@ def score(
         # Compute all possible vector-vector congruences.
 
         # Compute every pair for each mode
-        Cbig = ttb.tensor.from_function(np.zeros, (RA, RB, N))
+        Cbig = ttb.tensor(np.zeros((RA, RB, N), order=self.order))
         for n in range(N):
             Cbig[:, :, n] = np.abs(A.factor_matrices[n].T @ B.factor_matrices[n])
 

pyttb/sptensor.py

@@ -386,6 +386,11 @@ def copy(self) -> sptensor:
         """
         return ttb.sptensor(self.subs, self.vals, self.shape, copy=True)
 
+    @property
+    def order(self) -> Literal["F"]:
+        """Return the data layout of the underlying storage."""
+        return "F"
+
     def __deepcopy__(self, memo):
         """Return deep copy of this sptensor."""
         return self.copy()
@@ -708,7 +713,7 @@ def full(self) -> ttb.tensor:
             return ttb.tensor()
 
         # Create a dense zero tensor B that is the same shape as A
-        B = ttb.tensor(np.zeros(shape=self.shape), copy=False)
+        B = ttb.tensor(np.zeros(shape=self.shape, order=self.order), copy=False)
 
         if self.subs.size == 0:
             return B

pyttb/tenmat.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import logging
 from math import prod
 from typing import Literal, Optional, Tuple, Union
 
@@ -255,7 +256,12 @@ def to_tensor(self, copy: bool = True) -> ttb.tensor:
             data = self.data.copy()
         data = np.reshape(data, np.array(shape)[order], order=self.order)
         if order.size > 1:
-            data = np.transpose(data, np.argsort(order))
+            if not copy:
+                logging.warning(
+                    "This tenmat cannot be trivially unwrapped into tensor "
+                    "so must copy."
+                )
+            data = np.asfortranarray(np.transpose(data, np.argsort(order)))
         return ttb.tensor(data, shape, copy=False)
 
     def ctranspose(self) -> tenmat:

pyttb/tensor.py

@@ -152,7 +152,7 @@ def __init__(
                     f"Selected no copy, but input data isn't {self.order} ordered "
                     "so must copy."
                 )
-            self.data = data
+            self.data = np.asfortranarray(data)
         self.shape = shape
         return
 
@@ -611,6 +611,7 @@ def to_tenmat(
             (rprod, cprod),
             order=self.order,
         )
+        assert data.flags["F_CONTIGUOUS"]
         return ttb.tenmat(data, rdims, cdims, tshape=tshape, copy=copy)
 
     def innerprod(
@@ -1161,7 +1162,8 @@ def permute(self, order: OneDArray) -> tensor:
             return self.copy()
 
         # Np transpose does error checking on order, acts as permutation
-        return ttb.tensor(np.transpose(self.data, order), copy=False)
+
+        return ttb.tensor(np.asfortranarray(np.transpose(self.data, order)), copy=False)
 
     def reshape(self, shape: Shape) -> tensor:
         """
@@ -1361,7 +1363,7 @@ def symmetrize(  # noqa: PLR0912,PLR0915
                     avg = classSum / classNum
 
                 newdata = avg[linclassidx]
-                data = np.reshape(newdata, self.shape)
+                data = np.reshape(newdata, self.shape, order=self.order)
 
             return ttb.tensor(data, copy=False)
 
@@ -1521,7 +1523,7 @@ def ttm(
         )
         Y_data: np.ndarray = np.reshape(newdata, newshape, order=self.order)
         Y_data = np.transpose(Y_data, np.argsort(order))
-        return ttb.tensor(Y_data, copy=False)
+        return ttb.tensor(Y_data, copy=True)
 
     def ttt(
         self,
@@ -1880,12 +1882,20 @@ def tenfun_binary(
         if not isinstance(other, (float, int)):
             Y = other.data
         else:
-            Y = np.array(other)
+            Y = np.array(other, order=self.order)
 
         if not first:
             Y, X = X, Y
         data = function_handle(X, Y)
-        Z = ttb.tensor(data, copy=False)
+        copy = False
+        if not self._matches_order(data):
+            copy = True
+            logging.warning(
+                f"Tenfun function expects data of order {self.order}."
+                f" Update function to return data or the order to avoid "
+                "extra data copy."
+            )
+        Z = ttb.tensor(data, copy=copy)
         return Z
 
     def tenfun_unary(
@@ -1913,14 +1923,14 @@ def tenfun_unary(
                 ), f"Tensor {i} is not the same size as the first tensor input"
         if len(inputs) == 0:
             X = self.data
-            X = np.reshape(X, (1, -1))
+            X = np.reshape(X, (1, -1), order=self.order)
         else:
-            X = np.zeros((len(inputs) + 1, np.prod(sz)))
-            X[0, :] = np.reshape(self.data, (np.prod(sz)))
+            X = np.zeros((len(inputs) + 1, np.prod(sz)), order=self.order)
+            X[0, :] = np.reshape(self.data, (np.prod(sz)), order=self.order)
             for i, an_input in enumerate(inputs):
-                X[i + 1, :] = np.reshape(an_input.data, (np.prod(sz)))
+                X[i + 1, :] = np.reshape(an_input.data, (np.prod(sz)), order=self.order)
         data = function_handle(X)
-        data = np.reshape(data, sz)
+        data = np.reshape(data, sz, order=self.order)
         Z = ttb.tensor(data, copy=False)
         return Z
 
@@ -2170,7 +2180,8 @@ def __getitem__(self, item):  # noqa: PLR0912
             if newsiz.size == 0:
                 a = newdata.item()
             else:
-                a = ttb.tensor(newdata, copy=False)
+                # Copy data to ensure correct data ordering
+                a = ttb.tensor(newdata, copy=True)
             return a
 
         # *** CASE 2a: Subscript indexing ***

tests/test_tenmat.py

@@ -2,6 +2,7 @@
 # LLC (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the
 # U.S. Government retains certain rights in this software.
 
+import logging
 from copy import deepcopy
 
 import numpy as np
@@ -324,7 +325,7 @@ def test_tenmat_initialization_from_tensor_type(
         assert exc in str(excinfo)
 
 
-def test_tenmat_to_tensor():
+def test_tenmat_to_tensor(caplog):
     tensorInstance = ttb.tenrand((4, 3))
     tensorInstance4 = ttb.tenrand((4, 3, 2, 2))
     # tenmat
@@ -345,8 +346,11 @@ def test_tenmat_to_tensor():
     assert not np.may_share_memory(tensorTenmatInstance4.data, tenmatInstance4.data)
 
     # Reference instead of copy
-    tensorTenmatInstance4_ref = tenmatInstance4.to_tensor(copy=False)
-    assert np.may_share_memory(tensorTenmatInstance4_ref.data, tenmatInstance4.data)
+    with caplog.at_level(logging.WARNING):
+        tensorTenmatInstance4_ref = tenmatInstance4.to_tensor(copy=False)
+        assert not np.may_share_memory(
+            tensorTenmatInstance4_ref.data, tenmatInstance4.data
+        )
 
 
 def test_tenmat_ctranspose(sample_tenmat_4way):