From ea8e0463ef83293b32a6820f64173073e557596e Mon Sep 17 00:00:00 2001 From: Akshay Dubey <38462415+itsAkshayDubey@users.noreply.github.com> Date: Sat, 24 Sep 2022 18:48:12 +0530 Subject: [PATCH] Add Liouville lambda function (#3284) --- .../maths/LiouvilleLambdaFunction.java | 34 ++++++++++ .../maths/LiouvilleLambdaFunctionTest.java | 66 +++++++++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 src/main/java/com/thealgorithms/maths/LiouvilleLambdaFunction.java create mode 100644 src/test/java/com/thealgorithms/maths/LiouvilleLambdaFunctionTest.java diff --git a/src/main/java/com/thealgorithms/maths/LiouvilleLambdaFunction.java b/src/main/java/com/thealgorithms/maths/LiouvilleLambdaFunction.java new file mode 100644 index 000000000..3d49cec08 --- /dev/null +++ b/src/main/java/com/thealgorithms/maths/LiouvilleLambdaFunction.java @@ -0,0 +1,34 @@ +package com.thealgorithms.maths; + +/* + * Java program for liouville lambda function + * For any positive integer n, define λ(n) as the sum of the primitive nth roots of unity. + * It has values in {−1, 1} depending on the factorization of n into prime factors: + * λ(n) = +1 if n is a positive integer with an even number of prime factors. + * λ(n) = −1 if n is a positive integer with an odd number of prime factors. + * Wikipedia: https://en.wikipedia.org/wiki/Liouville_function + * + * Author: Akshay Dubey (https://github.com/itsAkshayDubey) + * + * */ + +public class LiouvilleLambdaFunction { + + /** + * This method returns λ(n) of given number n + * + * @param number Integer value which λ(n) is to be calculated + * @return 1 when number has even number of prime factors + * -1 when number has odd number of prime factors + * @throws IllegalArgumentException when number is negative + */ + static int liouvilleLambda(int number) { + if(number <= 0) { + //throw exception when number is less than or is zero + throw new IllegalArgumentException("Number must be greater than zero."); + } + + //return 1 if size of prime factor list is even, -1 otherwise + return PrimeFactorization.pfactors(number).size() % 2 == 0 ? 1 : -1; + } +} diff --git a/src/test/java/com/thealgorithms/maths/LiouvilleLambdaFunctionTest.java b/src/test/java/com/thealgorithms/maths/LiouvilleLambdaFunctionTest.java new file mode 100644 index 000000000..0959b6167 --- /dev/null +++ b/src/test/java/com/thealgorithms/maths/LiouvilleLambdaFunctionTest.java @@ -0,0 +1,66 @@ +package com.thealgorithms.maths; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +class LiouvilleLambdaFunctionTest { + + @Test + void testLiouvilleLambdaMustThrowExceptionIfNumberIsZero() { + //given + int number = 0; + String expectedMessage = "Number must be greater than zero."; + + //when + Exception exception = assertThrows(IllegalArgumentException.class, () -> { + LiouvilleLambdaFunction.liouvilleLambda(number); + }); + String actualMessage = exception.getMessage(); + + //then + assertEquals(expectedMessage, actualMessage); + } + + @Test + void testLiouvilleLambdaMustThrowExceptionIfNumberIsNegative() { + //given + int number = -1; + String expectedMessage = "Number must be greater than zero."; + + //when + Exception exception = assertThrows(IllegalArgumentException.class, () -> { + LiouvilleLambdaFunction.liouvilleLambda(number); + }); + String actualMessage = exception.getMessage(); + + //then + assertEquals(expectedMessage, actualMessage); + } + + @Test + void testLiouvilleLambdaMustReturnNegativeOne() { + //given + int number = 11; + int expectedOutput = -1; + + //when + int actualOutput = LiouvilleLambdaFunction.liouvilleLambda(number); + + //then + assertEquals(expectedOutput, actualOutput); + } + + @Test + void testLiouvilleLambdaMustReturnPositiveOne() { + //given + int number = 10; + int expectedOutput = 1; + + //when + int actualOutput = LiouvilleLambdaFunction.liouvilleLambda(number); + + //then + assertEquals(expectedOutput, actualOutput); + } +}