gcd_of_n_numbers.cpp File Reference

This program aims at calculating the GCD of n numbers. More...

#include <algorithm>
#include <array>
#include <cassert>
#include <iostream>

Include dependency graph for gcd_of_n_numbers.cpp:

Namespaces
namespace	math
	for IO operations
namespace	gcd_of_n_numbers
	Compute GCD of numbers in an array.

Functions
int	math::gcd_of_n_numbers::gcd_two (int x, int y)
	Function to compute GCD of 2 numbers x and y.
template<std::size_t n>
bool	math::gcd_of_n_numbers::check_all_zeros (const std::array< int, n > &a)
	Function to check if all elements in the array are 0.
template<std::size_t n>
int	math::gcd_of_n_numbers::gcd (const std::array< int, n > &a)
	Main program to compute GCD using the Euclidean algorithm.
static void	test ()
	Self-test implementation.
int	main ()
	Main function.

Detailed Description

This program aims at calculating the GCD of n numbers.

The GCD of n numbers can be calculated by repeatedly calculating the GCDs of pairs of numbers i.e. \(\gcd(a, b, c)\) = \(\gcd(\gcd(a, b), c)\) Euclidean algorithm helps calculate the GCD of each pair of numbers efficiently

See also

gcd_iterative_euclidean.cpp, gcd_recursive_euclidean.cpp

Function Documentation

check_all_zeros()

template<std::size_t n>

bool math::gcd_of_n_numbers::check_all_zeros

(

const std::array< int, n > &

a

)

Function to check if all elements in the array are 0.

Parameters

a	Array of numbers

Returns

'True' if all elements are 0

'False' if not all elements are 0

                                                {
  // Use std::all_of to simplify zero-checking
  return std::all_of(a.begin(), a.end(), [](int x) { return x == 0; });
}

Here is the call graph for this function:

gcd()

template<std::size_t n>

int math::gcd_of_n_numbers::gcd

(

const std::array< int, n > &

a

)

Main program to compute GCD using the Euclidean algorithm.

Parameters

a	Array of integers to compute GCD for

Returns

GCD of the numbers in the array or std::nullopt if undefined

                                   {
  // GCD is undefined if all elements in the array are 0
  if (check_all_zeros(a)) {
    return -1; // Use std::optional to represent undefined GCD
  }
 
  // divisors can be negative, we only want the positive value
  int result = std::abs(a[0]);
  for (std::size_t i = 1; i < n; ++i) {
    result = gcd_two(result, std::abs(a[i]));
    if (result == 1) {
      break; // Further computations still result in gcd of 1
    }
  }
  return result;
}

Here is the call graph for this function:

gcd_two()

int math::gcd_of_n_numbers::gcd_two	(	int	x,
		int	y )

Function to compute GCD of 2 numbers x and y.

Parameters

x	First number
y	Second number

Returns

GCD of x and y via recursion

                          {
  // base cases
  if (y == 0) {
    return x;
  }
  if (x == 0) {
    return y;
  }
  return gcd_two(y, x % y); // Euclidean method
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

           {
  test(); // run self-test implementation
  return 0;
}

Here is the call graph for this function:

test()

static void test ( )

static

Self-test implementation.

Returns

void

                   {
  std::array<int, 1> array_1 = {0};
  std::array<int, 1> array_2 = {1};
  std::array<int, 2> array_3 = {0, 2};
  std::array<int, 3> array_4 = {-60, 24, 18};
  std::array<int, 4> array_5 = {100, -100, -100, 200};
  std::array<int, 5> array_6 = {0, 0, 0, 0, 0};
  std::array<int, 7> array_7 = {10350, -24150, 0, 17250, 37950, -127650, 51750};
  std::array<int, 7> array_8 = {9500000, -12121200, 0, 4444, 0, 0, 123456789};
 
  assert(math::gcd_of_n_numbers::gcd(array_1) == -1);
  assert(math::gcd_of_n_numbers::gcd(array_2) == 1);
  assert(math::gcd_of_n_numbers::gcd(array_3) == 2);
  assert(math::gcd_of_n_numbers::gcd(array_4) == 6);
  assert(math::gcd_of_n_numbers::gcd(array_5) == 100);
  assert(math::gcd_of_n_numbers::gcd(array_6) == -1);
  assert(math::gcd_of_n_numbers::gcd(array_7) == 3450);
  assert(math::gcd_of_n_numbers::gcd(array_8) == 1);
}