Bausager/panic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Done with activation softmax backwards

Browse Source
This commit is contained in:
Bausager
2026-07-31 19:08:57 +02:00
parent d7b74ab40f
commit 11da534fd6
30 changed files with 3029 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/math/argmax.hpp
+176
View File
@@ -0,0 +1,176 @@
/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
*
* PANIC
* Portable Algorithms and Numerics In C++
*
* Scientific computing from scratch, with feeling.
*
* Copyright (c) 2026 Michelle Bausager
*
* This file is part of PANIC.
*
* PANIC is free software licensed under the GNU General Public License v3.0 or later.
* You may redistribute and/or modify it under the terms of the GPL.
*
* PANIC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the LICENSE file for the full license text.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* Project Name: PANIC
* Module Name: math
* File Name: argmax.hpp
* Revision: 0.1.0
* Date: 31-07-2026
* Author: Michelle Bausager
*
* Description:
* Functions to find the index of the maximum value;
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
#include <config/types.hpp>
#include <tensor/vector.hpp> // for panic::vector
#include <tensor/matrix.hpp> // for panic::matrix
namespace panic{
namespace math{
/**
* @brief Returns the index of maximum value of a vector
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a Input vector.
*
* @return A new vector containing the result.
* @return An empty vector if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::types::uint_t argmax(const panic::tensor::vector<T>& a);
/**
* @brief Calculates the index of the maximum value of a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param b Output vector for index
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
*/
template <typename T>
bool argmax(const panic::tensor::matrix<T>& A, panic::tensor::uint_vector& b);
/**
* @brief Returns the index of the maximum value of a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
*/
template <typename T>
panic::types::uint_t argmax(const panic::tensor::matrix<T>& A);
/**
* @brief Find the index of the maximum values row-wise of a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param C Output vector with indexes. Resized to match @p A.cols().
*
* @return true if @p c was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool argmax_rowwise(const panic::tensor::matrix<T>& A, panic::tensor::uint_vector& c);
/**
* @brief Returns a new matrix containing the index of the maiximum row-wise elementwise.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::uint_vector argmax_rowwise(const panic::tensor::matrix<T>& A);
/**
* @brief Find the index of the maximum values column-wise of a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param C Output matrix. Resized to match @p A.rows().
*
* @return true if @p c was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool argmax_colwise(const panic::tensor::matrix<T>& A, panic::tensor::uint_vector& c);
/**
* @brief Returns a new matrix containing the index of the maiximum column-wise elementwise.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::uint_vector argmax_colwise(const panic::tensor::matrix<T>& A);
} // namespace math
} // namespace panic
include/math/dot.hpp
+102
View File
@@ -0,0 +1,102 @@
/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* PANIC
* Portable Algorithms and Numerics In C++
*
* Scientific computing from scratch, with feeling.
*
* Copyright (c) 2026 Michelle Bausager
*
* This file is part of PANIC.
*
* PANIC is free software licensed under the GNU General Public License v3.0 or later.
* You may redistribute and/or modify it under the terms of the GPL.
*
* PANIC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the LICENSE file for the full license text.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* Project Name: PANIC
* Module Name: math
* File Name: dot.hpp
* Revision: 0.1.0
* Date: 31-07-2026
* Author: Michelle Bausager
*
* Description:
* Functions to calculate dot product of tensors;
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
//---------------------------------------------------------------------------------------------------------------------------
// INCLUDE DESCRIPTION
//-----------------------------------------------------------------------------------------------------
#include <tensor/vector.hpp>
#include <tensor/matrix.hpp> // for panic::real_matrix
namespace panic{
namespace math{
/**
* @brief Returns dor product of vector and vector.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a First vector.
* @param b Second vector for dot product. Need to be @p a.size()
*
*/
template <typename T>
T dot(const panic::tensor::vector<T>& a, const panic::tensor::vector<T>& b);
/**
* @brief Returns a new vector of dot product of a matrix and vector.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param b Input vector. @ p b.size needs to be the size of @p A.cols.
* @param c Output vector with result.
*
* @return true if success
* @return false if resizeing fails or dimention mismatch
*
*/
template <typename T>
bool dot(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& b, panic::tensor::vector<T>& c);
/**
* @brief Returns a new vector of dot product of a matrix and vector.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param b Input vector. @ p b.size needs to be the size of @p A.cols.
*
* @return A new matrix containing the result.
* @return An empty vector if the operation fails.
*
* @note This overload is convenient, but may allocate a new matrix.
*/
template <typename T>
panic::tensor::vector<T> dot(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& b);
} // namespace math
} // namespace panic
include/math/equal.hpp
+294
View File
@@ -0,0 +1,294 @@
/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
*
* PANIC
* Portable Algorithms and Numerics In C++
*
* Scientific computing from scratch, with feeling.
*
* Copyright (c) 2026 Michelle Bausager
*
* This file is part of PANIC.
*
* PANIC is free software licensed under the GNU General Public License v3.0 or later.
* You may redistribute and/or modify it under the terms of the GPL.
*
* PANIC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the LICENSE file for the full license text.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* Project Name: PANIC
* Module Name: math
* File Name: equal.hpp
* Revision: 0.1.0
* Date: 31-07-2026
* Author: Michelle Bausager
*
* Description:
* Functions to find the equal in panic::tensor
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* @file mul.hpp
* @brief Public API for multiplying operations on PANIC vectors and matrices.
*
* This header contains the declarations that users of the math module should call.
* The comments here describe how each function is used, what dimensions are required,
* and what is returned on failure.
*
* Implementation details, OpenMP thresholds, and explicit template instantiations are
* kept in mul.cpp.
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
#include <tensor/vector.hpp> // for panic::vector
#include <tensor/matrix.hpp> // for panic::matrix
namespace panic{
namespace math{
/**
* @brief Find the equal for a scalar to every element of a vector.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a Input vector.
* @param k Scalar value compared to each element of @p a.
* @param c Output vector. Resized to match @p a.
*
* @return true if @p c was resized and filled successfully.
* @return false if resizing @p c failed.
*
* @note This overload writes the result into an existing vector to avoid
* unnecessary temporary allocations.
*/
template <typename T>
bool equal(const panic::tensor::vector<T>& a, const T k, panic::tensor::vector<T>& c);
/**
* @brief Returns a new vector containing a scalar equaled to every element.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a Input vector.
* @param k Scalar value compared to each element of @p a.
*
* @return A new vector containing the result.
* @return An empty vector if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> equal(const panic::tensor::vector<T>& a, const T k);
/**
* @brief Equal a vector elementwise too a vector.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a First vector.
* @param b Second vector. Must have size of @p a
* @param c Output vector. Resized to match @p a.
*
* @return true if @p c was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool equal(const panic::tensor::vector<T>& a, const panic::tensor::vector<T>& b, panic::tensor::vector<T>& c);
/**
* @brief Returns a new vector containing a vector with equals elementwise.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param a First vector.
* @param b Second vector. Must have size of @p a
* @param k Scalar value compared to each element of @p a.
*
* @return A new vector containing the result.
* @return An empty vector if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> equal(const panic::tensor::vector<T>& a, const panic::tensor::vector<T>& b);
/**
* @brief Equal compared a scalar to every element of a matix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param k Scalar value multiplied to each element of @p A.
* @param C Output Matrix. Resized to match @p A.
*
* @return true if @p C was resized and filled successfully.
* @return false if resizing @p C failed.
*
* @note This overload writes the result into an existing vector to avoid
* unnecessary temporary allocations.
*/
template <typename T>
bool equal(const panic::tensor::matrix<T>& A, const T k, panic::tensor::matrix<T>& C);
/**
* @brief Returns a new matrix containing a scalar equal compared to every element.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param k Scalar value multiplied to each element of @p A.
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::matrix<T> equal(const panic::tensor::matrix<T>& A, const T k);
/**
* @brief Equal compared a matrix elementwise too a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A First matrix.
* @param B Second matrix. Must have size of @p A.
* @param C Output matrix. Resized to match @p A.
*
* @return true if @p C was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool equal(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& B, panic::tensor::matrix<T>& C);
/**
* @brief Returns a new matrix containing a matrix equal compaed elementwise.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param B Second matrix. Must have size of @p A.
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::matrix<T> equal(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& B);
/**
* @brief Equal compared a vector rowwise too a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Matrix.
* @param b Vector. Must have size of @p A.cols().
* @param C Output matrix. Resized to match @p A.
*
* @return true if @p C was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool equal_rowwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b, panic::tensor::matrix<T>& C);
/**
* @brief Equal compared a vector rowwise too a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Matrix.
* @param b Vector. Must have size of @p A.cols().
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::matrix<T> equal_rowwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b);
/**
* @brief Equal compared a vector colwise too a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Matrix.
* @param b Vector. Must have size of @p A.rows().
* @param C Output matrix. Resized to match @p A.
*
* @return true if @p C was resized and filled successfully.
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool equal_colwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b, panic::tensor::matrix<T>& C);
/**
* @brief Equal compared a vector colwise too a matrix.
*
* Computes:
* @code
* @endcode
*
* @tparam T Numeric element type.
* @param A Matrix.
* @param b Vector. Must have size of @p A.rows().
*
* @return A new matrix containing the result.
* @return An empty matrix if the operation fails.
*
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::matrix<T> equal_colwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b);
} // namespace math
} // namespace panic
include/math/exp.hpp
+1 -1
View File
@@ -99,7 +99,7 @@ bool exp(const panic::tensor::vector<T>& a, panic::tensor::vector<T>& c);
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> add(const panic::tensor::vector<T>& a);
panic::tensor::vector<T> exp(const panic::tensor::vector<T>& a);
/**
* @brief Calculates the expnential elementwise of a matrix
include/math/log.hpp
+18 -18
View File
@@ -24,11 +24,11 @@
* Module Name: math
* File Name: log.cpp
* Revision: 0.1.0
* Date: 29-07-2026
* Date: 31-07-2026
* Author: Michelle Bausager
*
* Description:
* Functions to calculate the logorithem of numbers
* Functions to calculate the natural logorithem of numbers
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
@@ -42,30 +42,30 @@ namespace math{
/**
* @brief calculates the exponential of a value.
* @brief calculates the log of a value.
*
* Computes:
* @code
* result = exp(k)
* result = log(k)
* @endcode
*
* @tparam T Numeric element type.
* @param k Value to take the exp of.
* @param x Value to take the log of.
*
* @return The calculated value
*
* @note This function is omp-friendly.
*/
template <typename T>
T exp(const T x);
T log(const T x);
/**
* @brief Calculates the exponential elementwise in a vector
* @brief Calculates the natrual logorithmic elementwise in a vector
*
* Computes:
* @code
* c[i] = exp(a[i])
* c[i] = log(a[i])
* @endcode
*
* @tparam T Numeric element type.
@@ -79,14 +79,14 @@ T exp(const T x);
* unnecessary temporary allocations.
*/
template <typename T>
bool exp(const panic::tensor::vector<T>& a, panic::tensor::vector<T>& c);
bool log(const panic::tensor::vector<T>& a, panic::tensor::vector<T>& c);
/**
* @brief Calculates the exponential elementwise in a vector
* @brief Calculates the natrual log elementwise in a vector
*
* Computes:
* @code
* result[i] = exp(a[i])
* result[i] = log(a[i])
* @endcode
*
* @tparam T Numeric element type.
@@ -98,14 +98,14 @@ bool exp(const panic::tensor::vector<T>& a, panic::tensor::vector<T>& c);
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> add(const panic::tensor::vector<T>& a);
panic::tensor::vector<T> log(const panic::tensor::vector<T>& a);
/**
* @brief Calculates the expnential elementwise of a matrix
* @brief Calculates the natrual log elementwise of a matrix
*
* Computes:
* @code
* C(i,j) = exp(A(i,j))
* C(i,j) = log(A(i,j))
* @endcode
*
* @tparam T Numeric element type.
@@ -119,14 +119,14 @@ panic::tensor::vector<T> add(const panic::tensor::vector<T>& a);
* unnecessary temporary allocations.
*/
template <typename T>
bool exp(const panic::tensor::matrix<T>& A, panic::tensor::matrix<T>& C);
bool log(const panic::tensor::matrix<T>& A, panic::tensor::matrix<T>& C);
/**
* @brief Returns the calculated ecponential elementwise of the matrix
* @brief Returns the calculated natrual log elementwise of the matrix
*
* Computes:
* @code
* result(i,j) = exp(A(i,j))
* result(i,j) = log(A(i,j))
* @endcode
*
* @tparam T Numeric element type.
@@ -138,7 +138,7 @@ bool exp(const panic::tensor::matrix<T>& A, panic::tensor::matrix<T>& C);
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::matrix<T> exp(const panic::tensor::matrix<T>& A);
panic::tensor::matrix<T> log(const panic::tensor::matrix<T>& A);
} // namespace math
} // namespace panic
include/math/mean.hpp
+7 -6
View File
@@ -33,6 +33,7 @@
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
#include <config/types.hpp>
#include <tensor/vector.hpp> // for panic::vector
#include <tensor/matrix.hpp> // for panic::matrix
@@ -60,7 +61,7 @@ namespace math{
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
T mean(const panic::tensor::vector<T>& a);
panic::types::real_t mean(const panic::tensor::vector<T>& a);
/**
* @brief Returns the mean value of a matrix.
@@ -78,7 +79,7 @@ T mean(const panic::tensor::vector<T>& a);
*
*/
template <typename T>
T mean(const panic::tensor::matrix<T>& A);
panic::types::real_t mean(const panic::tensor::matrix<T>& A);
/**
* @brief Find the mean values row-wise of a matrix.
@@ -96,7 +97,7 @@ T mean(const panic::tensor::matrix<T>& A);
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool mean_rowwise(const panic::tensor::matrix<T>& A, panic::tensor::vector<T>& c);
bool mean_rowwise(const panic::tensor::real_matrix& A, panic::tensor::real_vector& c);
/**
* @brief Returns a new matrix containing the mean row-wise elementwise.
@@ -115,7 +116,7 @@ bool mean_rowwise(const panic::tensor::matrix<T>& A, panic::tensor::vector<T>& c
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> mean_rowwise(const panic::tensor::matrix<T>& A);
panic::tensor::real_vector mean_rowwise(const panic::tensor::real_matrix& A);
/**
@@ -134,7 +135,7 @@ panic::tensor::vector<T> mean_rowwise(const panic::tensor::matrix<T>& A);
* @return false if vector sizes do not match or resizing @p c failed.
*/
template <typename T>
bool mean_colwise(const panic::tensor::matrix<T>& A, panic::tensor::vector<T>& c);
bool mean_colwise(const panic::tensor::real_matrix& A, panic::tensor::real_vector& c);
/**
* @brief Returns a new matrix containing the mean column-wise elementwise.
@@ -153,7 +154,7 @@ bool mean_colwise(const panic::tensor::matrix<T>& A, panic::tensor::vector<T>& c
* @note This overload is convenient, but may allocate a new vector.
*/
template <typename T>
panic::tensor::vector<T> mean_colwise(const panic::tensor::matrix<T>& A);
panic::tensor::real_vector mean_colwise(const panic::tensor::real_matrix& A);
} // namespace math
} // namespace panic
include/math/transpose.hpp
+86
View File
@@ -0,0 +1,86 @@
/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* PANIC
* Portable Algorithms and Numerics In C++
*
* Scientific computing from scratch, with feeling.
*
* Copyright (c) 2026 Michelle Bausager
*
* This file is part of PANIC.
*
* PANIC is free software licensed under the GNU General Public License v3.0 or later.
* You may redistribute and/or modify it under the terms of the GPL.
*
* PANIC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the LICENSE file for the full license text.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* Project Name: PANIC
* Module Name: math
* File Name: transpose.hpp
* Revision: 0.1.0
* Date: 31-07-2026
* Author: Michelle Bausager
*
* Description:
* Functions to transpose a matrix;
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
#pragma once
//---------------------------------------------------------------------------------------------------------------------------
// INCLUDE DESCRIPTION
//-----------------------------------------------------------------------------------------------------
#include <tensor/matrix.hpp> // for panic::real_matrix
namespace panic{
namespace math{
/**
* @brief Transposes a matrix.
*
* Computes:
* @code
* B = transpose(A)
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
* @param B Output matrix with result.
*
* @return true if success
* @return false if resizeing fails or dimention mismatch
*
*/
template <typename T>
bool transpose(const panic::tensor::matrix<T>& A, panic::tensor::matrix<T>& B);
/**
* @brief Returns a new matrix of the transposed A.
*
* Computes:
* @code
* result = transpose(A)
* @endcode
*
* @tparam T Numeric element type.
* @param A Input matrix.
*
* @return A new matrix containing the result.
* @return An empty vector if the operation fails.
*
* @note This overload is convenient, but may allocate a new matrix.
*/
template <typename T>
panic::tensor::matrix<T> transpose(const panic::tensor::matrix<T>& A);
} // namespace math
} // namespace panic