vector_cross_product.cpp

/**
 * @file
 *
 * @brief Calculates the [Cross Product](https://en.wikipedia.org/wiki/Cross_product) and the magnitude of two mathematical 3D vectors.
 *
 *
 * @details Cross Product of two vectors gives a vector.
 * Direction Ratios of a vector are the numeric parts of the given vector. They are the tree parts of the
 * vector which determine the magnitude (value) of the vector.
 * The method of finding a cross product is the same as finding the determinant of an order 3 matrix consisting
 * of the first row with unit vectors of magnitude 1, the second row with the direction ratios of the
 * first vector and the third row with the direction ratios of the second vector.
 * The magnitude of a vector is it's value expressed as a number.
 * Let the direction ratios of the first vector, P be: a, b, c
 * Let the direction ratios of the second vector, Q be: x, y, z
 * Therefore the calculation for the cross product can be arranged as:
 *
 * ```
 * P x Q:
 *  	1	1	1
 *  	a	b	c
 *  	x	y	z
 * ```
 *
 * The direction ratios (DR) are calculated as follows:
 *  	1st DR, J:  (b * z) - (c * y)
 *  	2nd DR, A: -((a * z) - (c * x))
 *  	3rd DR, N:  (a * y) - (b * x)
 *
 * Therefore, the direction ratios of the cross product are: J, A, N
 * The following C++ Program calculates the direction ratios of the cross products of two vector.
 * The program uses a function, cross() for doing so.
 * The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
 *
 * Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
 *
 * ### Example:
 * An example of a running instance of the executable program:
 *
 * 	Pass the first Vector: 1 2 3
 *	Pass the second Vector: 4 5 6
 *	The cross product is: -3 6 -3
 *	Magnitude: 7.34847
 *
 * @author [Shreyas Sable](https://github.com/Shreyas-OwO)
 */

#include <iostream>
#include <array>
#include <cmath>
#include <cassert>

/**
 * @namespace math
 * @brief Math algorithms
 */
namespace math {
	/**
	 * @namespace vector_cross
	 * @brief Functions for Vector Cross Product algorithms
	 */
	namespace vector_cross {
		/**
		 * @brief Function to calculate the cross product of the passed arrays containing the direction ratios of the two mathematical vectors.
		 * @param A contains the direction ratios of the first mathematical vector.
		 * @param B contains the direction ration of the second mathematical vector.
		 * @returns the direction ratios of the cross product.
		 */
		std::array<double, 3> cross(const std::array<double, 3> &A, const std::array<double, 3> &B) {
			std::array<double, 3> product;
			/// Performs the cross product as shown in @algorithm.
			product[0] = (A[1] * B[2]) - (A[2] * B[1]);
			product[1] = -((A[0] * B[2]) - (A[2] * B[0]));
			product[2] = (A[0] * B[1]) - (A[1] * B[0]);
			return product;
		}

		/**
		 * @brief Calculates the magnitude of the mathematical vector from it's direction ratios.
		 * @param vec an array containing the direction ratios of a mathematical vector.
		 * @returns type: double description: the magnitude of the mathematical vector from the given direction ratios.
		 */
		double mag(const std::array<double, 3> &vec) {
			double magnitude = sqrt((vec[0] * vec[0]) + (vec[1] * vec[1]) + (vec[2] * vec[2]));
			return magnitude;
		}
	} /// namespace vector_cross
} /// namespace math

/**
 * @brief test function.
 * @details test the cross() and the mag() functions.
 */
static void test() {
	/// Tests the cross() function.
	std::array<double, 3> t_vec = math::vector_cross::cross({1, 2, 3}, {4, 5, 6});
	assert(t_vec[0] == -3 && t_vec[1] == 6 && t_vec[2] == -3);

	/// Tests the mag() function.
	double t_mag = math::vector_cross::mag({6, 8, 0});
	assert(t_mag == 10);
}

/**
 * @brief Main Function
 * @details Asks the user to enter the direction ratios for each of the two mathematical vectors using std::cin
 * @returns 0 on exit
 */
int main() {

	/// Tests the functions with sample input before asking for user input.
	test();

	std::array<double, 3> vec1;
	std::array<double, 3> vec2;

	/// Gets the values for the first vector.
	std::cout << "\nPass the first Vector: ";
	std::cin >> vec1[0] >> vec1[1] >> vec1[2];

	/// Gets the values for the second vector.
	std::cout << "\nPass the second Vector: ";
	std::cin >> vec2[0] >> vec2[1] >> vec2[2];

	/// Displays the output out.
	std::array<double, 3> product = math::vector_cross::cross(vec1, vec2);
	std::cout << "\nThe cross product is: " << product[0] << " " << product[1] << " " << product[2] << std::endl;

	/// Displays the magnitude of the cross product.
	std::cout << "Magnitude: " << math::vector_cross::mag(product) << "\n" << std::endl;

	return 0;
}