Here you can find the source of lcm(int a, int b)
Returns the least common multiple of the absolute value of two numbers, using the formula lcm(a,b) = (a / gcd(a,b)) * b.
| Parameter | Description |
|---|---|
| a | any number |
| b | any number |
| Parameter | Description |
|---|---|
| ArithmeticException | if the result cannot be represented as a nonnegative intvalue |
public static int lcm(int a, int b)
//package com.java2s; /*/*from w w w. j ava2s. c o m*/ * Copyright (c) 2006-2011 Karsten Schmidt * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * http://creativecommons.org/licenses/LGPL/2.1/ * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ public class Main { /** * <p> * Returns the least common multiple of the absolute value of two numbers, * using the formula <code>lcm(a,b) = (a / gcd(a,b)) * b</code>. * </p> * Special cases: * <ul> * <li>The invocations <code>lcm(Integer.MIN_VALUE, n)</code> and * <code>lcm(n, Integer.MIN_VALUE)</code>, where <code>abs(n)</code> is a * power of 2, throw an <code>ArithmeticException</code>, because the result * would be 2^31, which is too large for an int value.</li> * <li>The result of <code>lcm(0, x)</code> and <code>lcm(x, 0)</code> is * <code>0</code> for any <code>x</code>. * </ul> * * @param a any number * @param b any number * @return the least common multiple, never negative * @throws ArithmeticException * if the result cannot be represented as a nonnegative int * value * @since 1.1 */ public static int lcm(int a, int b) { if (a == 0 || b == 0) { return 0; } int lcm = Math.abs(mulAndCheck(a / gcd(a, b), b)); //if (lcm == Integer.MIN_VALUE){return 0;} return lcm; } /** * @param x * @return absolute value of x */ public static final double abs(double x) { return x < 0 ? -x : x; } /** * @param x * @return absolute value of x */ public static final float abs(float x) { return x < 0 ? -x : x; } /** * @param x * @return absolute value of x */ public static final int abs(int x) { int y = x >> 31; return (x ^ y) - y; } /** * Multiply two integers, checking for overflow. * * @param x a factor * @param y a factor * @return the product <code>x*y</code> * @throws ArithmeticException if the result can not be represented as an * int * @since 1.1 */ public static int mulAndCheck(int x, int y) { long m = ((long) x) * ((long) y); if (m < Integer.MIN_VALUE || m > Integer.MAX_VALUE) { return 0; } return (int) m; } /** * <p> * Gets the greatest common divisor of the absolute value of two numbers, * using the "binary gcd" method which avoids division and modulo * operations. See Knuth 4.5.2 algorithm B. This algorithm is due to Josef * Stein (1961). * </p> * Special cases: * <ul> * <li>The invocations * <code>gcd(Integer.MIN_VALUE, Integer.MIN_VALUE)</code>, * <code>gcd(Integer.MIN_VALUE, 0)</code> and * <code>gcd(0, Integer.MIN_VALUE)</code> throw an * <code>ArithmeticException</code>, because the result would be 2^31, which * is too large for an int value.</li> * <li>The result of <code>gcd(x, x)</code>, <code>gcd(0, x)</code> and * <code>gcd(x, 0)</code> is the absolute value of <code>x</code>, except * for the special cases above. * <li>The invocation <code>gcd(0, 0)</code> is the only one which returns * <code>0</code>.</li> * </ul> * * @param p any number * @param q any number * @return the greatest common divisor, never negative * @throws ArithmeticException * if the result cannot be represented as a nonnegative int * value * @since 1.1 */ public static int gcd(final int p, final int q) { int u = p; int v = q; if ((u == 0) || (v == 0)) { if ((u == Integer.MIN_VALUE) || (v == Integer.MIN_VALUE)) { return 0; } return (Math.abs(u) + Math.abs(v)); } // keep u and v negative, as negative integers range down to // -2^31, while positive numbers can only be as large as 2^31-1 // (i.e. we can't necessarily negate a negative number without // overflow) /* assert u!=0 && v!=0; */ if (u > 0) { u = -u; } // make u negative if (v > 0) { v = -v; } // make v negative // B1. [Find power of 2] int k = 0; while ((u & 1) == 0 && (v & 1) == 0 && k < 31) { // while u and v are // both even... u /= 2; v /= 2; k++; // cast out twos. } if (k == 31) { return 0; } // B2. Initialize: u and v have been divided by 2^k and at least // one is odd. int t = ((u & 1) == 1) ? v : -(u / 2)/* B3 */; // t negative: u was odd, v may be even (t replaces v) // t positive: u was even, v is odd (t replaces u) do { /* assert u<0 && v<0; */ // B4/B3: cast out twos from t. while ((t & 1) == 0) { // while t is even.. t /= 2; // cast out twos } // B5 [reset max(u,v)] if (t > 0) { u = -t; } else { v = t; } // B6/B3. at this point both u and v should be odd. t = (v - u) / 2; // |u| larger: t positive (replace u) // |v| larger: t negative (replace v) } while (t != 0); return -u * (1 << k); // gcd is u*2^k } }