Activation Softmax Forward done

src/math/div.cpp

@@ -0,0 +1,625 @@
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ *
+ *                                              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:         div.cpp
+ * Revision:          0.1.0
+ * Date:              25-06-2026
+ * Author:            Michelle Bausager
+ *
+ * Description:
+ * Functions to divdes panic::tensor
+ *
+ *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+//---------------------------------------------------------------------------------------------------------------------------
+// INCLUDE DESCRIPTION
+//-----------------------------------------------------------------------------------------------------
+
+#include <math/div.hpp>
+#include <config/omp.hpp>
+
+#include <tensor/vector.hpp> // for panic::vector
+#include <tensor/matrix.hpp> // for panic::matrix
+
+//---------------------------------------------------------------------------------------------------------------------------
+// PRIVATE CONSTANTS
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * @brief Minimum number of element operations before using the OpenMP-enabled loop.
+ *
+ * Small vectors and matrices are kept serial because the overhead of starting
+ * worker threads can be larger than the work itself.
+ */
+static const panic::types::uint_t div_omp_min_work = 500;
+//---------------------------------------------------------------------------------------------------------------------------
+// INPLEMENTATION
+//---------------------------------------------------------------------------------------------------------------------------
+
+namespace panic {
+	namespace math {
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divedes a constant to a vector
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div(const panic::tensor::vector<T>& a, const T k, panic::tensor::vector<T>& c){
+
+	if (!c.resize(a.size())){
+		return false;
+	}
+
+	if (k == T{0}){
+		return false;
+	}
+
+	PANIC_OMP_PARALLEL_FOR_IF(a.size() > div_omp_min_work)
+	for (panic::types::uint_t i = 0; i < a.size(); ++i){
+		c[i] = a[i] / k;
+	}
+
+	return true;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div<panic::types::uint_t>(const panic::tensor::vector<panic::types::uint_t>& a, 
+										const panic::types::uint_t k, 
+										panic::tensor::vector<panic::types::uint_t>& c
+);
+template bool div<panic::types::int_t>(const panic::tensor::vector<panic::types::int_t>& a, 
+										const panic::types::int_t k, 
+										panic::tensor::vector<panic::types::int_t>& c
+);
+template bool div<panic::types::real_t>(const panic::tensor::vector<panic::types::real_t>& a, 
+										const panic::types::real_t k, 
+										panic::tensor::vector<panic::types::real_t>& c
+);
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a constant to a vector
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::vector<T> div(const panic::tensor::vector<T>& a, const T k){
+	panic::tensor::vector<T> c(a.size());
+
+	if (!div(a, k, c)){
+		return panic::tensor::vector<T>();
+	}
+
+	return c;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::vector<panic::types::uint_t> 
+				div(const panic::tensor::vector<panic::types::uint_t>& a, 
+					const panic::types::uint_t k
+);
+template panic::tensor::vector<panic::types::int_t> 
+				div(const panic::tensor::vector<panic::types::int_t>& a, 
+					const panic::types::int_t k
+);
+template panic::tensor::vector<panic::types::real_t> 
+				div(const panic::tensor::vector<panic::types::real_t>& a, 
+					const panic::types::real_t k
+);
+
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a vector to a vector
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div(const panic::tensor::vector<T>& a, const panic::tensor::vector<T>& b, panic::tensor::vector<T>& c){
+
+	if (a.size() != b.size()){
+		return false;
+	}
+
+	if (!c.resize(a.size())){
+		return false;
+	}
+
+	bool valid = true;
+
+	// Check all divisors in parallel.
+	// valid remains true only if every divisor is nonzero.
+	PANIC_OMP_PARALLEL_FOR_REDUCTION_IF( a.size() > div_omp_min_work, &&, valid )
+	for (panic::types::uint_t i = 0; i < a.size(); ++i){
+		const bool nonzero = b[i] != T{0};
+		valid = valid && nonzero;
+
+		if (nonzero){
+			c[i] = a[i] / b[i];
+		}
+	}
+
+	return valid;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div(const panic::tensor::vector<panic::types::uint_t>& a, 
+				const panic::tensor::vector<panic::types::uint_t>& b, 
+				panic::tensor::vector<panic::types::uint_t>& c
+);
+template bool div(const panic::tensor::vector<panic::types::int_t>& a, 
+				const panic::tensor::vector<panic::types::int_t>& b, 
+				panic::tensor::vector<panic::types::int_t>& c
+);
+template bool div(const panic::tensor::vector<panic::types::real_t>& a, 
+				const panic::tensor::vector<panic::types::real_t>& b, 
+				panic::tensor::vector<panic::types::real_t>& c
+);
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a vector to a vector
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::vector<T> div(const panic::tensor::vector<T>& a, const panic::tensor::vector<T>& b){
+	panic::tensor::vector<T> c(a.size());
+
+	if (!div(a, b, c)){
+		return panic::tensor::vector<T>();
+	}
+
+	return c;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::vector<panic::types::uint_t> 
+					div(const panic::tensor::vector<panic::types::uint_t>& a, 
+						const panic::tensor::vector<panic::types::uint_t>& b
+);
+template panic::tensor::vector<panic::types::int_t> 
+					div(const panic::tensor::vector<panic::types::int_t>& a, 
+						const panic::tensor::vector<panic::types::int_t>& b
+);
+template panic::tensor::vector<panic::types::real_t> 
+					div(const panic::tensor::vector<panic::types::real_t>& a, 
+						const panic::tensor::vector<panic::types::real_t>& b
+);
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a constant to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div(const panic::tensor::matrix<T>& A, const T k, panic::tensor::matrix<T>& C){
+
+	panic::types::uint_t rows = A.rows();
+	panic::types::uint_t cols = A.cols();
+	panic::types::uint_t work = rows*cols;
+
+	if ( !C.resize(rows, cols) ){
+		return false;
+	}
+
+	if (k == T{0}){
+		return false;
+	}
+
+
+	PANIC_OMP_PARALLEL_FOR_IF(work > div_omp_min_work)
+	for (panic::types::uint_t i = 0; i < rows; ++i){
+		for (panic::types::uint_t j = 0; j < cols; ++j){
+			C(i,j) = A(i,j) / k;
+		}
+		
+	}
+
+	return true;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div(const panic::tensor::matrix<panic::types::uint_t>& A, 
+					const panic::types::uint_t k, 
+					panic::tensor::matrix<panic::types::uint_t>& C
+);
+template bool div(const panic::tensor::matrix<panic::types::int_t>& A, 
+					const panic::types::int_t k, 
+					panic::tensor::matrix<panic::types::int_t>& C
+);
+template bool div(const panic::tensor::matrix<panic::types::real_t>& A, 
+					const panic::types::real_t k, 
+					panic::tensor::matrix<panic::types::real_t>& C
+);
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a constant to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::matrix<T> div(const panic::tensor::matrix<T>& A, const T k){
+	panic::tensor::matrix<T> C;
+
+	if (!div(A, k, C)){
+		return panic::tensor::matrix<T>();
+	}
+
+	return C;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::matrix<panic::types::uint_t> 
+						div(const panic::tensor::matrix<panic::types::uint_t>& A, 
+							const panic::types::uint_t k
+);
+template panic::tensor::matrix<panic::types::int_t> 
+						div(const panic::tensor::matrix<panic::types::int_t>& A, 
+							const panic::types::int_t k
+);
+template panic::tensor::matrix<panic::types::real_t> 
+						div(const panic::tensor::matrix<panic::types::real_t>& A, 
+							const panic::types::real_t k
+);
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a matrix to a matrix elementwise
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& B, panic::tensor::matrix<T>& C){
+
+	panic::types::uint_t rows = A.rows();
+	panic::types::uint_t cols = A.cols();
+	panic::types::uint_t work = rows*cols;
+
+	if ( (rows != B.rows()) || (cols != B.cols())){
+		return false;
+	}
+
+	if ( !C.resize(rows, cols) ){
+		return false;
+	}
+
+	bool valid = true;
+
+	// Check all divisors in parallel.
+	// valid remains true only if every divisor is nonzero.
+	PANIC_OMP_PARALLEL_FOR_REDUCTION_IF( work > div_omp_min_work, &&, valid )
+	for (panic::types::uint_t i = 0; i < rows; ++i) {
+	    for (panic::types::uint_t j = 0; j < cols; ++j) {
+
+	        const bool nonzero = B(i,j) != T{0};
+	        valid = valid && nonzero;
+
+	        if (nonzero) {
+	            C(i,j) = A(i,j) / B(i,j);
+	        }
+	    }
+	}
+
+
+	return valid;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div(const panic::tensor::matrix<panic::types::uint_t>& A, 
+					const panic::tensor::matrix<panic::types::uint_t>& B, 
+					panic::tensor::matrix<panic::types::uint_t>& C
+);
+template bool div(const panic::tensor::matrix<panic::types::int_t>& A, 
+					const panic::tensor::matrix<panic::types::int_t>& B, 
+					panic::tensor::matrix<panic::types::int_t>& C
+);
+template bool div(const panic::tensor::matrix<panic::types::real_t>& A, 
+					const panic::tensor::matrix<panic::types::real_t>& B, 
+					panic::tensor::matrix<panic::types::real_t>& C
+);
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div
+//
+// Description:
+//		Divides a matrix to a matrix elementwise
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::matrix<T> div(const panic::tensor::matrix<T>& A, const panic::tensor::matrix<T>& B){
+	panic::tensor::matrix<T> C;
+
+	if (!div(A, B, C)){
+		return panic::tensor::matrix<T>();
+	}
+
+	return C;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::matrix<panic::types::uint_t> 
+				div(const panic::tensor::matrix<panic::types::uint_t>& A, 
+					const panic::tensor::matrix<panic::types::uint_t>& B
+);
+template panic::tensor::matrix<panic::types::int_t> 
+				div(const panic::tensor::matrix<panic::types::int_t>& A, 
+					const panic::tensor::matrix<panic::types::int_t>& B
+);
+template panic::tensor::matrix<panic::types::real_t> 
+				div(const panic::tensor::matrix<panic::types::real_t>& A, 
+					const panic::tensor::matrix<panic::types::real_t>& B
+);
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div_rowwise
+//
+// Description:
+//		Divides a vector row-wise to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div_rowwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b, panic::tensor::matrix<T>& C){
+
+	panic::types::uint_t rows = A.rows();
+	panic::types::uint_t cols = A.cols();
+	panic::types::uint_t work = rows*cols;
+
+	if ( cols != b.size() ){
+		return false;
+	}
+
+	if ( !C.resize(rows, cols) ){
+		return false;
+	}
+
+
+	bool valid = true;
+
+	// Check all divisors in parallel.
+	// valid remains true only if every divisor is nonzero.
+	PANIC_OMP_PARALLEL_FOR_REDUCTION_IF( work > div_omp_min_work, &&, valid )
+	for (panic::types::uint_t i = 0; i < cols; ++i){
+		const bool nonzero = b[i] != T{0};
+		valid = valid && nonzero;
+		for (panic::types::uint_t j = 0; j < rows; ++j){
+			if (nonzero){
+				C(j,i) = A(j,i) / b[i];
+			}
+		}
+		
+	}
+
+	return valid;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div_rowwise(const panic::tensor::matrix<panic::types::uint_t>& A, 
+							const panic::tensor::vector<panic::types::uint_t>& b, 
+							panic::tensor::matrix<panic::types::uint_t>& C
+);
+template bool div_rowwise(const panic::tensor::matrix<panic::types::int_t>& A, 
+							const panic::tensor::vector<panic::types::int_t>& b, 
+							panic::tensor::matrix<panic::types::int_t>& C
+);
+template bool div_rowwise(const panic::tensor::matrix<panic::types::real_t>& A, 
+							const panic::tensor::vector<panic::types::real_t>& b, 
+							panic::tensor::matrix<panic::types::real_t>& C
+);
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div_rowwise
+//
+// Description:
+//		Divides a vector row-wise to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::matrix<T> div_rowwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b){
+	panic::tensor::matrix<T> C;
+
+	if (!div_rowwise(A, b, C)){
+		return panic::tensor::matrix<T>();
+	}
+
+	return C;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::matrix<panic::types::uint_t> 
+					div_rowwise(const panic::tensor::matrix<panic::types::uint_t>& A, 
+								const panic::tensor::vector<panic::types::uint_t>& b
+);
+template panic::tensor::matrix<panic::types::int_t> 
+					div_rowwise(const panic::tensor::matrix<panic::types::int_t>& A, 
+								const panic::tensor::vector<panic::types::int_t>& b
+);
+template panic::tensor::matrix<panic::types::real_t> 
+					div_rowwise(const panic::tensor::matrix<panic::types::real_t>& A, 
+								const panic::tensor::vector<panic::types::real_t>& b
+);
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div_colwise
+//
+// Description:
+//		Divides a vector coloumn-wise to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+bool div_colwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b, panic::tensor::matrix<T>& C){
+
+	panic::types::uint_t rows = A.rows();
+	panic::types::uint_t cols = A.cols();
+	panic::types::uint_t work = rows*cols;
+
+	if ( rows != b.size() ){
+		return false;
+	}
+
+	if ( !C.resize(rows, cols) ){
+		return false;
+	}
+
+	bool valid = true;
+
+	// Check all divisors in parallel.
+	// valid remains true only if every divisor is nonzero.
+	PANIC_OMP_PARALLEL_FOR_REDUCTION_IF( work > div_omp_min_work, &&, valid )
+	for (panic::types::uint_t i = 0; i < rows; ++i){
+		const bool nonzero = b[i] != T{0};
+		valid = valid && nonzero;
+		for (panic::types::uint_t j = 0; j < cols; ++j){
+			if (nonzero){
+				C(i,j) = A(i,j) / b[i];
+			}
+		}
+		
+	}
+
+	return valid;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template bool div_colwise(const panic::tensor::matrix<panic::types::uint_t>& A, 
+							const panic::tensor::vector<panic::types::uint_t>& b, 
+							panic::tensor::matrix<panic::types::uint_t>& C
+);
+template bool div_colwise(const panic::tensor::matrix<panic::types::int_t>& A, 
+							const panic::tensor::vector<panic::types::int_t>& b, 
+							panic::tensor::matrix<panic::types::int_t>& C
+);
+template bool div_colwise(const panic::tensor::matrix<panic::types::real_t>& A, 
+							const panic::tensor::vector<panic::types::real_t>& b, 
+							panic::tensor::matrix<panic::types::real_t>& C
+);
+
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+// Function Name : panic::math::div_colwise
+//
+// Description:
+//		Divides a vector coloumn-wise to a matrix
+//--------------------------------------------------------------------------------------------------------------------------
+template <typename T>
+panic::tensor::matrix<T> div_colwise(const panic::tensor::matrix<T>& A, const panic::tensor::vector<T>& b){
+	panic::tensor::matrix<T> C;
+
+
+	if (!div_colwise(A, b, C)){
+		return panic::tensor::matrix<T>();
+	}
+
+	return C;
+}
+//--------------------------------------------------------------------------------------------------------------------------
+// EXPLICIT TEMPLATE INSTANTIATION
+//
+// The implementation is in this .cpp file.
+// Build the overload for the official PANIC numeric types.
+//--------------------------------------------------------------------------------------------------------------------------
+template panic::tensor::matrix<panic::types::uint_t> 
+					div_colwise(const panic::tensor::matrix<panic::types::uint_t>& A, 
+								const panic::tensor::vector<panic::types::uint_t>& b
+);
+template panic::tensor::matrix<panic::types::int_t> 
+					div_colwise(const panic::tensor::matrix<panic::types::int_t>& A, 
+								const panic::tensor::vector<panic::types::int_t>& b
+);
+template panic::tensor::matrix<panic::types::real_t> 
+					div_colwise(const panic::tensor::matrix<panic::types::real_t>& A, 
+								const panic::tensor::vector<panic::types::real_t>& b
+);
+
+
+
+	} // namespace math
+} // namespace panic