Open In App

# Expressing a fraction as a natural number under modulo ‘m’

Given two integers A and B where A is not divisible by B, the task is to express A / B as a natural number modulo m where m = 1000000007
Note: This representation is useful where we need to express Probability of an event, Area of Curves and polygons etc.
Examples:

Input: A = 2, B = 6
Output: 333333336
Input: A = 4, B = 5
Output: 600000005

Approach: We know that, A / B can be written as A * (1 / B) i.e. A * (B ^ -1).
It is known that the modulo(%) operator satisfies the relation:

`(a * b) % m = ( (a % m) * (b % m) ) % m`

So, we can write:

`(b ^ -1) % m = (b ^ m-2) % m (Fermat's little theorem)`

Therefore the result will be:

`( (A mod m) * ( power(B, m-2) % m) ) % m`

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long int``#define m 1000000007` `// Function to return the GCD of given numbers``int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(a == 0)``        ``return` `b;``    ``return` `gcd(b % a, a);``}` `// Recursive function to return (x ^ n) % m``ll modexp(ll x, ll n)``{``    ``if` `(n == 0) {``        ``return` `1;``    ``}``    ``else` `if` `(n % 2 == 0) {``        ``return` `modexp((x * x) % m, n / 2);``    ``}``    ``else` `{``        ``return` `(x * modexp((x * x) % m, (n - 1) / 2) % m);``    ``}``}` `// Function to return the fraction modulo mod``ll getFractionModulo(ll a, ll b)``{``    ``ll c = gcd(a, b);` `    ``a = a / c;``    ``b = b / c;` `    ``// (b ^ m-2) % m``    ``ll d = modexp(b, m - 2);` `    ``// Final answer``    ``ll ans = ((a % m) * (d % m)) % m;` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``ll a = 2, b = 6;` `    ``cout << getFractionModulo(a, b) << endl;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `import` `java.io.*;` `class` `GFG {``    `   `static` `long` `m  = ``1000000007``;` `// Function to return the GCD of given numbers`` ``static` `long` `gcd(``long` `a, ``long` `b)``{``    ``if` `(a == ``0``)``        ``return` `b;``    ``return` `gcd(b % a, a);``}` `// Recursive function to return (x ^ n) % m``static` `long` `modexp(``long` `x, ``long` `n)``{``    ``if` `(n == ``0``) {``        ``return` `1``;``    ``}``    ``else` `if` `(n % ``2` `== ``0``) {``        ``return` `modexp((x * x) % m, n / ``2``);``    ``}``    ``else` `{``        ``return` `(x * modexp((x * x) % m, (n - ``1``) / ``2``) % m);``    ``}``}` `// Function to return the fraction modulo mod`` ``static` `long` `getFractionModulo(``long` `a, ``long` `b)``{``    ``long` `c = gcd(a, b);` `    ``a = a / c;``    ``b = b / c;` `    ``// (b ^ m-2) % m``    ``long`  `d = modexp(b, m - ``2``);` `    ``// Final answer``    ``long` `ans = ((a % m) * (d % m)) % m;` `    ``return` `ans;``}` `// Driver code` `    ``public` `static` `void` `main (String[] args) {``        ``long` `a = ``2``, b = ``6``;` `    ``System.out.println(getFractionModulo(a, b));``    ``}``}``// This code is contributed by inder_verma`

## Python3

 `# Python3 implementation of the approach``m ``=` `1000000007` `# Function to return the GCD``# of given numbers``def` `gcd(a, b):` `    ``if` `(a ``=``=` `0``):``        ``return` `b``    ``return` `gcd(b ``%` `a, a)` `# Recursive function to return (x ^ n) % m``def` `modexp(x, n):` `    ``if` `(n ``=``=` `0``) :``        ``return` `1``    ` `    ``elif` `(n ``%` `2` `=``=` `0``) :``        ``return` `modexp((x ``*` `x) ``%` `m, n ``/``/` `2``)``    ` `    ``else` `:``        ``return` `(x ``*` `modexp((x ``*` `x) ``%` `m,``                           ``(n ``-` `1``) ``/` `2``) ``%` `m)`  `# Function to return the fraction modulo mod``def` `getFractionModulo(a, b):` `    ``c ``=` `gcd(a, b)` `    ``a ``=` `a ``/``/` `c``    ``b ``=` `b ``/``/` `c` `    ``# (b ^ m-2) % m``    ``d ``=` `modexp(b, m ``-` `2``)` `    ``# Final answer``    ``ans ``=` `((a ``%` `m) ``*` `(d ``%` `m)) ``%` `m` `    ``return` `ans` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `2``    ``b ``=` `6` `    ``print` `( getFractionModulo(a, b))` `# This code is contributed by ita_c`

## C#

 `//C#  implementation of the approach` `using` `System;` `public` `class` `GFG{``    `  `static` `long` `m = 1000000007;` `// Function to return the GCD of given numbers``static` `long` `gcd(``long` `a, ``long` `b)``{``    ``if` `(a == 0)``        ``return` `b;``    ``return` `gcd(b % a, a);``}` `// Recursive function to return (x ^ n) % m``static` `long` `modexp(``long` `x, ``long` `n)``{``    ``if` `(n == 0) {``        ``return` `1;``    ``}``    ``else` `if` `(n % 2 == 0) {``        ``return` `modexp((x * x) % m, n / 2);``    ``}``    ``else` `{``        ``return` `(x * modexp((x * x) % m, (n - 1) / 2) % m);``    ``}``}` `// Function to return the fraction modulo mod``static` `long` `getFractionModulo(``long` `a, ``long` `b)``{``    ``long` `c = gcd(a, b);` `    ``a = a / c;``    ``b = b / c;` `    ``// (b ^ m-2) % m``    ``long` `d = modexp(b, m - 2);` `    ``// Final answer``    ``long` `ans = ((a % m) * (d % m)) % m;` `    ``return` `ans;``}` `// Driver code``    ` `    ``static` `public` `void` `Main (){``        ` `        ``long` `a = 2, b = 6;``        ``Console.WriteLine(getFractionModulo(a, b));``    ``}``}`

## PHP

 ``

## Javascript

 ``

Output:

`333333336`

Time Complexity: O(log(min(a, b) + logm)
Auxiliary Space: O(log(min(a, b) + logm)

#### Approach#2: Using fermat’s little

This approach computes the value of (A/B) % m using Fermat’s Little Theorem to calculate the modular inverse of B.

#### Algorithm

1. Define a function inverse_modulo(a, m) to compute the inverse of a modulo m using Fermat’s Little Theorem.
2. Define a function fraction_to_natural_modulo(A, B, m) to compute the value of (A/B) % m, where A, B, and m are given integers.
3. Inside the fraction_to_natural_modulo function, calculate the inverse of B modulo m using the inverse_modulo function.
4. Multiply A and the inverse of B modulo m, and take modulo m to get the result.
5. Return the result

## Python3

 `def` `inverse_modulo(a, m):``    ``"""``    ``Computes the inverse of a modulo m using Fermat's Little Theorem``    ``"""``    ``return` `pow``(a, m``-``2``, m)` `def` `fraction_to_natural_modulo(A, B, m):``    ``"""``    ``Computes the value of (A/B) % m, where A, B and m are given integers``    ``"""``    ``inverse_B ``=` `inverse_modulo(B, m)``    ``result ``=` `(A ``*` `inverse_B) ``%` `m``    ``return` `result` `# Example usage``A ``=` `2``B ``=` `6``m ``=` `1000000007``natural_number ``=` `fraction_to_natural_modulo(A, B, m)``print``(natural_number)`

Output

`333333336`

Time complexity:
The time complexity of this code is O(log m) because it uses the pow() function to compute the inverse modulo.

Auxiliary Space:
The space complexity of this code is O(1) because it only stores a few integers in memory.