Geometric mean (Two Methods)

Given an array of n elements, we need to find the geometric mean of the numbers. Generally geometric mean of n numbers is the n^th root of their product. 

   If there are n elements x1, x2, x3, . . ., xn
   in an array and if we want to calculate the 
   geometric mean of the array elements is
   Geometric mean = (x1 * x2 * x3 * . . . * xn)1/n 

Examples:

Input : arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
Output : 3.76435
        = (1 * 2 * 3 * 4 * 5 * 6 * 7 * 8)1/8
        = 403201/8
        = 3.76435

Input : arr[] = {15, 12, 13, 19, 10}
Output : 13.447
        = (15 * 12 * 13 * 19 * 10)1/5
        = 4446001/5
        = 13.477

A simple solution is to multiply all numbers first, then find (1/n)-th power of the multiplication. 

C++

// Program to calculate the geometric mean
// of the given array elements.
#include <bits/stdc++.h>
using namespace std;

// function to calculate geometric mean
// and return float value.
float geometricMean(int arr[], int n)
{
    // declare product variable and
    // initialize it to 1.
    float product = 1;

    // Compute the product of all the
    // elements in the array.
    for (int i = 0; i < n; i++)
        product = product * arr[i];

    // compute geometric mean through formula
    // pow(product, 1/n) and return the value
    // to main function.
    float gm = pow(product, (float)1 / n);
    return gm;
}

// Driver function
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << geometricMean(arr, n);
    return 0;
}

Java

// Program to calculate the geometric mean
// of the given array elements.
import java.math.*;

class GFG{

    // function to calculate geometric mean
    // and return float value.
    static float geometricMean(int arr[], int n)
    {
        // declare product variable and
        // initialize it to 1.
        float product = 1;

        // Compute the product of all the
        // elements in the array.
        for (int i = 0; i < n; i++)
            product = product * arr[i];

        // compute geometric mean through
        // formula pow(product, 1/n) and
        // return the value to main function.
        float gm = (float)Math.pow(product, (float)1 / n);
        return gm;
    }

    // Driver function
    public static void main(String args[])
    {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
        int n = arr.length ;
        System.out.println(geometricMean(arr, n));
    }
}

/*This code is contributed by Nikita Tiwari*/

Python

# Python Program to calculate the
# geometric mean of the given
# array elements.
import math

# function to calculate geometric
# mean and return float value.
def geometricMean(arr, n) :

    # declare product variable and
    # initialize it to 1.
    product = 1

    # Compute the product of all the
    # elements in the array.
    for i in range(0,n) :
        product = product * arr[i]

    # compute geometric mean through
    # formula pow(product, 1/n) and
    # return the value to main function.
    gm = (float)(math.pow(product, (1 / n)))
    return (float)(gm)


# Driver function
arr = [ 1, 2, 3, 4, 5, 6, 7, 8]
n = len(arr)

# to print 6 digits after decimal
print ('{0:.6f}'.format(geometricMean(arr, n)))


# This code is contributed by Nikita Tiwari

C#

// Program to calculate the geometric mean
// of the given array elements.
using System;

class GFG{

    // function to calculate geometric mean
    // and return float value.
    static float geometricMean(int []arr, int n)
    {
        // declare product variable and
        // initialize it to 1.
        float product = 1;

        // Compute the product of all the
        // elements in the array.
        for (int i = 0; i < n; i++)
            product = product * arr[i];

        // compute geometric mean through
        // formula pow(product, 1/n) and
        // return the value to main function.
        float gm = (float)Math.Pow(product, (float)1 / n);
        return gm;
    }

    // Driver function
    public static void Main()
    {
        int []arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
        int n = arr.Length ;
        Console.WriteLine(geometricMean(arr, n));
    }
}

/*This code is contributed by vt_m*/

PHP

<?php
// Program to calculate the geometric mean
// of the given array elements.

// function to calculate geometric mean
// and return float value.
function geometricMean($arr, $n)
{

    // declare product variable and
    // initialize it to 1.
    $product = 1;

    // Compute the product of all the
    // elements in the array.
    for ($i = 0; $i < $n; $i++)
        $product = $product * $arr[$i];

    // compute geometric mean through formula
    // pow(product, 1/n) and return the value
    // to main function.
    $gm = pow($product, (float)(1 / $n));
    return $gm;
}

// Driver Code
$arr = array(1, 2, 3, 4, 5, 6, 7, 8);
$n = sizeof($arr);
echo(geometricMean($arr, $n));

// This code is contributed by Ajit.
?>

Javascript

<script>
// Javascript program to calculate the geometric mean
// of the given array elements.

    // function to calculate geometric mean
    // and return float value.
    function geometricMean(arr, n)
    {
        // declare product variable and
        // initialize it to 1.
        let product = 1;

        // Compute the product of all the
        // elements in the array.
        for (let i = 0; i < n; i++)
            product = product * arr[i];

        // compute geometric mean through
        // formula pow(product, 1/n) and
        // return the value to main function.
        let gm = Math.pow(product, 1 / n);
        return gm;
    }

// driver function

        let arr = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
        let n = arr.length ;
        document.write(geometricMean(arr, n));

   // This code is contributed by code_hunt.
</script>

Output: 

3.76435

Time Complexity: O(n) where n is size of given array

Auxiliary Space: O(1)

The above solution simply causes overflow. A better solution is to use log. There are n numbers and we need to calculate geometric mean using the formula : 

Geometric mean = Antilog((log(x1) + log(x2) +
                 log(x3) + . . . + log(xn))/n)  

For calculating the Antilog in programming we use exponent function (exp()). 

C++

// Program to calculate the geometric mean
// of the given array elements.
#include <bits/stdc++.h>
using namespace std;

// function to calculate geometric mean
// and return float value.
float geometricMean(int arr[], int n)
{
    // declare sum variable and
    // initialize it to 1.
    float sum = 0;

    // Compute the sum of all the
    // elements in the array.
    for (int i = 0; i < n; i++)
        sum = sum + log(arr[i]);

    // compute geometric mean through formula
    // antilog(((log(1) + log(2) + . . . + log(n))/n)
    // and return the value to main function.
    sum = sum / n;

    return exp(sum);
}

// Driver function
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    // function call
    cout << geometricMean(arr, n);
    return 0;
}

Java

// Java Program to calculate the geometric mean
// of the given array elements.
import java.io.*;

class GFG
{

    // function to calculate geometric mean
    // and return float value.
    static float geometricMean(int []arr, int n)
    {
        // declare sum variable and
        // initialize it to 1.
        float sum = 0;

        // Compute the sum of all the
        // elements in the array.
        for (int i = 0; i < n; i++)
            sum = sum + (float)Math.log(arr[i]);

        // compute geometric mean through formula
        // antilog(((log(1) + log(2) + . . . + log(n))/n)
        // and return the value to main function.
        sum = sum / n;

        return (float)Math.exp(sum);
    }

    // Driver function
    public static void main (String[] args)
    {
        int []arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
        int n = arr.length;

        // function call
        System.out.println(geometricMean(arr, n));

    }
}

// This code is contributed by vt_m.

Python3

# Program to calculate the
# geometric mean of the
# given array elements.
import math

# function to calculate
# geometric mean and
# return float value.
def geometricMean(arr, n):

    # declare sum variable and
    # initialize it to 1.
    sum = 0;

    # Compute the sum of all
    # the elements in the array.
    for i in range(n):
        sum = sum + math.log(arr[i]);

    # compute geometric mean
    # through formula antilog
    # (((log(1) + log(2) + . .
    # ... + log(n))/n)
    # and return the value to
    # main function.
    sum = sum / n;

    return math.exp(sum);

# Driver Code
arr= [ 1, 2, 3, 4, 5, 6, 7, 8 ];
n = len(arr);

# function call
print(geometricMean(arr, n));

# This code is contributed by mits.

C#

// Program to calculate the geometric mean
// of the given array elements.
using System;

class GFG {

    // function to calculate geometric mean
    // and return float value.
    static float geometricMean(int []arr, int n)
    {
        // declare sum variable and
        // initialize it to 1.
        float sum = 0;

        // Compute the sum of all the
        // elements in the array.
        for (int i = 0; i < n; i++)
            sum = sum + (float)Math.Log(arr[i]);

        // compute geometric mean through formula
        // antilog(((log(1) + log(2) + . . . + log(n))/n)
        // and return the value to main function.
        sum = sum / n;

        return (float)Math.Exp(sum);
    }

    // Driver function
    public static void Main ()
    {
        int []arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
        int n = arr.Length;

        // function call
        Console.WriteLine(geometricMean(arr, n));

    }
}

// This code is contributed by vt_m.

PHP

<?php
// Program to calculate the geometric mean
// of the given array elements.

// function to calculate geometric mean
// and return float value.
function geometricMean($arr, $n)
{

    // declare sum variable and
    // initialize it to 1.
    $sum = 0;

    // Compute the sum of all the
    // elements in the array.
    for($i = 0; $i < $n; $i++)
        $sum = $sum + log($arr[$i]);

    // compute geometric mean
    // through formula
    // antilog(((log(1) + log(2) +
    // . . . + log(n))/n)
    // and return the value
    $sum = $sum / $n;

    return exp($sum);
}

    // Driver Code
    $arr = array(1, 2, 3, 4, 5, 6, 7, 8);
    $n = count($arr);

    // function call
    echo geometricMean($arr, $n);

// This code is contributed by anuj_67.
?>

Javascript

<script>

// Program to calculate the geometric mean
// of the given array elements.


    // function to calculate geometric mean
    // and return float value.

    function geometricMean(arr, n)
    {
        // declare sum variable and
        // initialize it to 1.
        var sum = 0;

        // Compute the sum of all the
        // elements in the array.
        for (var i = 0; i < n; i++)
            sum = sum + Math.log(arr[i]);

        // compute geometric mean through formula
        // antilog(((log(1) + log(2) + . . . + log(n))/n)
        // and return the value to main function.

        sum = sum / n;

        return Math.exp(sum);
    }

    // Driver function

        var arr = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
        var n = arr.length;

        // function call
        document.write(geometricMean(arr, n).toFixed(5));

 // This code is contributed by bunnyram19.
</script>

Output:

3.76435

Time Complexity: O(n)

Auxiliary Space: O(1)