반응형
Java BigInteger의 제곱근을 어떻게 찾을 수 있습니까?
BigInteger의 제곱근을 찾는 라이브러리가 있습니까? 나는 그것을 오프라인으로 계산하기를 원합니다. 루프 내부가 아닌 한 번만. 따라서 계산 비용이 많이 드는 솔루션이라도 괜찮습니다.
알고리즘을 찾아서 구현하고 싶지 않습니다. 쉽게 사용할 수 있는 솔루션이 완벽할 것입니다.
재미로:
public static BigInteger sqrt(BigInteger x) {
BigInteger div = BigInteger.ZERO.setBit(x.bitLength()/2);
BigInteger div2 = div;
// Loop until we hit the same value twice in a row, or wind
// up alternating.
for(;;) {
BigInteger y = div.add(x.divide(div)).shiftRight(1);
if (y.equals(div) || y.equals(div2))
return y;
div2 = div;
div = y;
}
}
귀하의 질문에 대한 라이브러리 솔루션이 없다는 것을 알고 있습니다. 어딘가에서 외부 라이브러리 솔루션을 가져와야 합니다. 아래에서 설명하는 것은 외부 라이브러리를 얻는 것보다 덜 복잡합니다.
아래와 같이 두 개의 정적 메서드를 사용하여 클래스에서 고유한 외부 라이브러리 솔루션을 만들고 외부 라이브러리 컬렉션에 추가할 수 있습니다. 메서드는 인스턴스 메서드일 필요가 없으므로 정적이며 편리하게는 이를 사용하기 위해 클래스를 인스턴스화할 필요가 없습니다. 정수 제곱근의 표준은 하한 값(즉, 제곱근보다 작거나 같은 가장 큰 정수)이므로 하한 값에 대해 아래 클래스에서 하나의 정적 메서드인 floor 메서드만 필요할 수 있으며 다음을 선택할 수 있습니다. 천장(즉, 제곱근보다 크거나 같은 가장 작은 정수) 메서드 버전을 무시합니다. 지금은 기본 패키지에 있지만 패키지 문을 추가하여 편리한 패키지에 넣을 수 있습니다.
방법은 아주 간단하고 반복은 가장 가까운 정수 답으로 매우 빠르게 수렴됩니다. 부정적인 인수를 제공하려고 하면 IllegalArgumentException이 발생합니다. 예외를 다른 예외로 변경할 수 있지만 부정 인수가 일종의 예외를 발생시키거나 최소한 계산을 시도하지 않도록 해야 합니다. 음수의 정수 제곱근은 허수의 영역이 아니기 때문에 존재하지 않습니다.
이것들은 수세기 동안 수작업 계산에 사용되어 온 아주 잘 알려진 단순 반복 정수 제곱근 알고리즘에서 비롯됩니다. 더 나은 추정으로 수렴하기 위해 과대 평가 및 과소 평가를 평균화하여 작동합니다. 이것은 추정치가 원하는 만큼 가까워질 때까지 반복될 수 있습니다.
이들은 y1 = ((x/y0) + y0) / 2를 기반으로 하여 가장 큰 정수 yn으로 수렴합니다. 여기서 yn * yn <= x입니다.
그러면 y * y <= x 및 (y + 1) * (y + 1) > x인 x의 BigInteger 제곱근 y에 대한 하한값이 제공됩니다.
적응은 y * y >= x 및 (y - 1) * (y - 1) < x인 x의 BigInteger 제곱근 y에 대한 상한 값을 제공할 수 있습니다.
두 가지 방법 모두 테스트되었으며 작동합니다. 그들은 여기에 있습니다:
import java.math.BigInteger;
public class BigIntSqRoot {
public static BigInteger bigIntSqRootFloor(BigInteger x)
throws IllegalArgumentException {
if (x.compareTo(BigInteger.ZERO) < 0) {
throw new IllegalArgumentException("Negative argument.");
}
// square roots of 0 and 1 are trivial and
// y == 0 will cause a divide-by-zero exception
if (x .equals(BigInteger.ZERO) || x.equals(BigInteger.ONE)) {
return x;
} // end if
BigInteger two = BigInteger.valueOf(2L);
BigInteger y;
// starting with y = x / 2 avoids magnitude issues with x squared
for (y = x.divide(two);
y.compareTo(x.divide(y)) > 0;
y = ((x.divide(y)).add(y)).divide(two));
return y;
} // end bigIntSqRootFloor
public static BigInteger bigIntSqRootCeil(BigInteger x)
throws IllegalArgumentException {
if (x.compareTo(BigInteger.ZERO) < 0) {
throw new IllegalArgumentException("Negative argument.");
}
// square roots of 0 and 1 are trivial and
// y == 0 will cause a divide-by-zero exception
if (x == BigInteger.ZERO || x == BigInteger.ONE) {
return x;
} // end if
BigInteger two = BigInteger.valueOf(2L);
BigInteger y;
// starting with y = x / 2 avoids magnitude issues with x squared
for (y = x.divide(two);
y.compareTo(x.divide(y)) > 0;
y = ((x.divide(y)).add(y)).divide(two));
if (x.compareTo(y.multiply(y)) == 0) {
return y;
} else {
return y.add(BigInteger.ONE);
}
} // end bigIntSqRootCeil
} // end class bigIntSqRoot
나는 그것들의 정확성을 확인할 수 없지만 인터넷 검색을 할 때 몇 가지 집에서 만든 솔루션이 있습니다. 그 중 최고는 다음과 같습니다. http://www.merriampark.com/bigsqrt.htm
또한 Apache commons Math 프로젝트를 시도하십시오(Apache가 JCP 블로그 게시물 이후 폭격에서 복구되면).
아무도 이전에 언급하지 않았지만 Java 9에서는 BigInteger에 sqrt가 있으므로 이상하게도 다음과 같이 사용할 수 있습니다.
BigInteger nine = BigInteger.valueOf(9);
BigInteger three = nine.sqrt();
https://docs.oracle.com/javase/9/docs/api/java/math/BigInteger.html#sqrt--
으로 Jigar는 미국, 뉴턴의 반복은 모두 이해하고 구현하는 것은 매우 간단하다. 이것이 숫자의 제곱근을 찾는 데 가장 효율적인 알고리즘인지 아닌지는 다른 사람들에게 맡기겠습니다.
재귀를 사용하면 약 두 줄로 수행할 수 있습니다.
private static BigInteger newtonIteration(BigInteger n, BigInteger x0)
{
final BigInteger x1 = n.divide(x0).add(x0).shiftRight(1);
return x0.equals(x1)||x0.equals(x1.subtract(BigInteger.ONE)) ? x0 : newtonIteration(n, x1);
}
여기서 n 은 제곱근을 찾고자 하는 숫자 이고 x0 은 이전 호출의 숫자이며 다른 메서드에서 첫 번째 호출을 시작할 때 항상 1이 됩니다. 따라서 바람직하게는 이와 같은 것으로 보완할 것입니다.
public static BigInteger sqrt(final BigInteger number)
{
if(number.signum() == -1)
throw new ArithmeticException("We can only calculate the square root of positive numbers.");
return newtonIteration(number, BigInteger.ONE);
}
2차 체를 구현하기 위해 BigIntegers에 대한 제곱근이 필요했습니다. 여기에서 일부 솔루션을 사용했지만 지금까지 절대적으로 가장 빠르고 최고의 솔루션은 Google Guava의 BigInteger 라이브러리에서 가져온 것입니다.
상당히 가벼운 대안적인 접근 방식입니다. 속도 측면에서 Newton 방법을 사용하는 Mantono의 답변은 특정 경우에 더 바람직할 수 있습니다.
여기 내 접근 방식이 있습니다 ...
public static BigInteger sqrt(BigInteger n) {
BigInteger a = BigInteger.ONE;
BigInteger b = n.shiftRight(1).add(new BigInteger("2")); // (n >> 1) + 2 (ensure 0 doesn't show up)
while (b.compareTo(a) >= 0) {
BigInteger mid = a.add(b).shiftRight(1); // (a+b) >> 1
if (mid.multiply(mid).compareTo(n) > 0)
b = mid.subtract(BigInteger.ONE);
else
a = mid.add(BigInteger.ONE);
}
return a.subtract(BigInteger.ONE);
}
내가 사용할 초기 추측 Math.sqrt(bi.doubleValue())을 위해 이미 제안된 링크를 사용하여 답변을 더 정확하게 만들 수 있습니다.
이것은 내가 찾은 최고의 (가장 짧은) 작업 솔루션입니다.
http://faruk.akgul.org/blog/javas-missing-algorithm-biginteger-sqrt/
코드는 다음과 같습니다.
public static BigInteger sqrt(BigInteger n) {
BigInteger a = BigInteger.ONE;
BigInteger b = new BigInteger(n.shiftRight(5).add(new BigInteger("8")).toString());
while(b.compareTo(a) >= 0) {
BigInteger mid = new BigInteger(a.add(b).shiftRight(1).toString());
if(mid.multiply(mid).compareTo(n) > 0) b = mid.subtract(BigInteger.ONE);
else a = mid.add(BigInteger.ONE);
}
return a.subtract(BigInteger.ONE);
}
나는 그것을 테스트했고 올바르게 작동하고 있습니다 (빠른 것 같습니다)
BigDecimal BDtwo = new BigDecimal("2");
BigDecimal BDtol = new BigDecimal(".000000001");
private BigDecimal bigIntSQRT(BigDecimal lNew, BigDecimal lOld, BigDecimal n) {
lNew = lOld.add(n.divide(lOld, 9, BigDecimal.ROUND_FLOOR)).divide(BDtwo, 9, BigDecimal.ROUND_FLOOR);
if (lOld.subtract(lNew).abs().compareTo(BDtol) == 1) {
lNew = bigIntSQRT(lNew, lNew, n);
}
return lNew;
}
저는 이 문제를 해결하기 위해 작업 중이었고 Java로 재귀 제곱근 찾기를 성공적으로 작성했습니다. BDtol 을 원하는 대로 변경할 수 있지만 이는 상당히 빠르게 실행되고 결과적으로 다음 예제를 제공했습니다.
원래 번호 1467839114233645767430925372993335637692683931121739087571335401020890062659255388686508254301
SQRT --> 383123885216472214589586756787577295328224028242477055.000000000
그런 다음 확인을 위해 1467839114233645767430925372993356376926839311217390875713354010208000000062659255180268650825402
Jim의 답변을 단순화 하고 성능을 개선했습니다.
public class BigIntSqRoot {
private static BigInteger two = BigInteger.valueOf(2L);
public static BigInteger bigIntSqRootFloor(BigInteger x)
throws IllegalArgumentException {
if (checkTrivial(x)) {
return x;
}
if (x.bitLength() < 64) { // Can be cast to long
double sqrt = Math.sqrt(x.longValue());
return BigInteger.valueOf(Math.round(sqrt));
}
// starting with y = x / 2 avoids magnitude issues with x squared
BigInteger y = x.divide(two);
BigInteger value = x.divide(y);
while (y.compareTo(value) > 0) {
y = value.add(y).divide(two);
value = x.divide(y);
}
return y;
}
public static BigInteger bigIntSqRootCeil(BigInteger x)
throws IllegalArgumentException {
BigInteger y = bigIntSqRootFloor(x);
if (x.compareTo(y.multiply(y)) == 0) {
return y;
}
return y.add(BigInteger.ONE);
}
private static boolean checkTrivial(BigInteger x) {
if (x == null) {
throw new NullPointerException("x can't be null");
}
if (x.compareTo(BigInteger.ZERO) < 0) {
throw new IllegalArgumentException("Negative argument.");
}
// square roots of 0 and 1 are trivial and
// y == 0 will cause a divide-by-zero exception
if (x.equals(BigInteger.ZERO) || x.equals(BigInteger.ONE)) {
return true;
} // end if
return false;
}
}
업데이트(2018년 7월 23일) : 이 기술은 더 큰 값에는 적용되지 않는 것 같습니다. 아래 바이너리 검색을 기반으로 다른 기술을 게시했습니다.
인수분해에 대해 알아보고 있었는데 이 글을 작성하게 되었습니다.
package com.example.so.math;
import java.math.BigInteger;
/**
*
* <p>https://stackoverflow.com/questions/4407839/how-can-i-find-the-square-root-of-a-java-biginteger</p>
* @author Ravindra
* @since 06August2017
*
*/
public class BigIntegerSquareRoot {
public static void main(String[] args) {
int[] values = {5,11,25,31,36,42,49,64,100,121};
for (int i : values) {
BigInteger result = handleSquareRoot(BigInteger.valueOf(i));
System.out.println(i+":"+result);
}
}
private static BigInteger handleSquareRoot(BigInteger modulus) {
int MAX_LOOP_COUNT = 100; // arbitrary for now.. but needs to be proportional to sqrt(modulus)
BigInteger result = null;
if( modulus.equals(BigInteger.ONE) ) {
result = BigInteger.ONE;
return result;
}
for(int i=2;i<MAX_LOOP_COUNT && i<modulus.intValue();i++) { // base-values can be list of primes...
//System.out.println("i"+i);
BigInteger bigIntegerBaseTemp = BigInteger.valueOf(i);
BigInteger bigIntegerRemainderTemp = bigIntegerBaseTemp.modPow(modulus, modulus);
BigInteger bigIntegerRemainderSubtractedByBase = bigIntegerRemainderTemp.subtract(bigIntegerBaseTemp);
BigInteger bigIntegerRemainderSubtractedByBaseFinal = bigIntegerRemainderSubtractedByBase;
BigInteger resultTemp = null;
if(bigIntegerRemainderSubtractedByBase.signum() == -1 || bigIntegerRemainderSubtractedByBase.signum() == 1) {
bigIntegerRemainderSubtractedByBaseFinal = bigIntegerRemainderSubtractedByBase.add(modulus);
resultTemp = bigIntegerRemainderSubtractedByBaseFinal.gcd(modulus);
} else if(bigIntegerRemainderSubtractedByBase.signum() == 0) {
resultTemp = bigIntegerBaseTemp.gcd(modulus);
}
if( resultTemp.multiply(resultTemp).equals(modulus) ) {
System.out.println("Found square root for modulus :"+modulus);
result = resultTemp;
break;
}
}
return result;
}
}
접근 방식은 다음과 같이 시각화할 수 있습니다.
도움이 되었기를 바랍니다!
나는 제곱근의 정수 부분까지만 갈 것이지만 이 대략적인 알고리즘을 수정하여 원하는 만큼 더 정확하게 갈 수 있습니다.
public static void main(String args[]) {
BigInteger N = new BigInteger(
"17976931348623159077293051907890247336179769789423065727343008115"
+ "77326758055056206869853794492129829595855013875371640157101398586"
+ "47833778606925583497541085196591615128057575940752635007475935288"
+ "71082364994994077189561705436114947486504671101510156394068052754"
+ "0071584560878577663743040086340742855278549092581");
System.out.println(N.toString(10).length());
String sqrt = "";
BigInteger divisor = BigInteger.ZERO;
BigInteger toDivide = BigInteger.ZERO;
String Nstr = N.toString(10);
if (Nstr.length() % 2 == 1)
Nstr = "0" + Nstr;
for (int digitCount = 0; digitCount < Nstr.length(); digitCount += 2) {
toDivide = toDivide.multiply(BigInteger.TEN).multiply(
BigInteger.TEN);
toDivide = toDivide.add(new BigInteger(Nstr.substring(digitCount,
digitCount + 2)));
String div = divisor.toString(10);
divisor = divisor.add(new BigInteger(
div.substring(div.length() - 1)));
int into = tryMax(divisor, toDivide);
divisor = divisor.multiply(BigInteger.TEN).add(
BigInteger.valueOf(into));
toDivide = toDivide.subtract(divisor.multiply(BigInteger
.valueOf(into)));
sqrt = sqrt + into;
}
System.out.println(String.format("Sqrt(%s) = %s", N, sqrt));
}
private static int tryMax(final BigInteger divisor,
final BigInteger toDivide) {
for (int i = 9; i > 0; i--) {
BigInteger div = divisor.multiply(BigInteger.TEN).add(
BigInteger.valueOf(i));
if (div.multiply(BigInteger.valueOf(i)).compareTo(toDivide) <= 0)
return i;
}
return 0;
}
C# 언어는 Java와 유사한 구문을 가지고 있습니다. 이 재귀 솔루션을 작성했습니다.
static BigInteger fsqrt(BigInteger n)
{
string sn = n.ToString();
return guess(n, BigInteger.Parse(sn.Substring(0, sn.Length >> 1)), 0);
}
static BigInteger guess(BigInteger n, BigInteger g, BigInteger last)
{
if (last >= g - 1 && last <= g + 1) return g;
else return guess(n, (g + (n / g)) >> 1, g);
}
이 코드를 다음과 같이 호출하십시오(Java에서는 "System.out.print"일 것 같습니다).
Console.WriteLine(fsqrt(BigInteger.Parse("783648276815623658365871365876257862874628734627835648726")));
그리고 답은 27993718524262253829858552106입니다.
면책 조항: 이 방법이 10보다 작은 숫자에는 작동하지 않는다는 것을 이해합니다. 이것은 BigInteger 제곱근 방법입니다.
이것은 쉽게 해결됩니다. 첫 번째 방법을 다음과 같이 변경하여 재귀 부분에 숨을 쉴 수 있는 공간을 제공합니다.
static BigInteger fsqrt(BigInteger n)
{
if (n > 999)
{
string sn = n.ToString();
return guess(n, BigInteger.Parse(sn.Substring(0, sn.Length >> 1)), 0);
}
else return guess(n, n >> 1, 0);
}
이진 검색을 사용하여 x의 제곱근을 찾을 수도 있습니다. 예를 들어 10^10으로 곱하고 m^2 이후 이진 검색으로 m과 같은 정수를 찾을 수도 있습니다.
System.out.println(m.divide(10^5)+"."+m.mod(10^5));다음은 BigInteger.multiply 또는 BigInteger.divide를 사용하지 않는 솔루션입니다.
private static final BigInteger ZERO = BigInteger.ZERO;
private static final BigInteger ONE = BigInteger.ONE;
private static final BigInteger TWO = BigInteger.valueOf(2);
private static final BigInteger THREE = BigInteger.valueOf(3);
/**
* This method computes sqrt(n) in O(n.bitLength()) time,
* and computes it exactly. By "exactly", I mean it returns
* not only the (floor of the) square root s, but also the
* remainder r, such that r >= 0, n = s^2 + r, and
* n < (s + 1)^2.
*
* @param n The argument n, as described above.
*
* @return An array of two values, where the first element
* of the array is s and the second is r, as
* described above.
*
* @throws IllegalArgumentException if n is not nonnegative.
*/
public static BigInteger[] sqrt(BigInteger n) {
if (n == null || n.signum() < 0) {
throw new IllegalArgumentException();
}
int bl = n.bitLength();
if ((bl & 1) != 0) {
++ bl;
}
BigInteger s = ZERO;
BigInteger r = ZERO;
while (bl >= 2) {
s = s.shiftLeft(1);
BigInteger crumb = n.testBit(-- bl)
? (n.testBit(-- bl) ? THREE : TWO)
: (n.testBit(-- bl) ? ONE : ZERO);
r = r.shiftLeft(2).add(crumb);
BigInteger d = s.shiftLeft(1);
if (d.compareTo(r) < 0) {
s = s.add(ONE);
r = r.subtract(d).subtract(ONE);
}
}
assert r.signum() >= 0;
assert n.equals(s.multiply(s).add(r));
assert n.compareTo(s.add(ONE).multiply(s.add(ONE))) < 0;
return new BigInteger[] {s, r};
}
위에 게시한 답변은 많은 수에서는 작동하지 않습니다(그러나 흥미롭게도 그렇습니다!). 이와 같이 정확성에 대한 제곱근을 결정하기 위한 이진 검색 접근 방식을 게시합니다.
package com.example.so.squareroot;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
/**
* <p>https://stackoverflow.com/questions/4407839/how-can-i-find-the-square-root-of-a-java-biginteger</p>
* <p> Determine square-root of a number or its closest whole number (binary-search-approach) </p>
* @author Ravindra
* @since 07-July-2018
*
*/
public class BigIntegerSquareRootV2 {
public static void main(String[] args) {
List<BigInteger> listOfSquares = new ArrayList<BigInteger>();
listOfSquares.add(BigInteger.valueOf(5).multiply(BigInteger.valueOf(5)).pow(2));
listOfSquares.add(BigInteger.valueOf(11).multiply(BigInteger.valueOf(11)).pow(2));
listOfSquares.add(BigInteger.valueOf(15485863).multiply(BigInteger.valueOf(10000019)).pow(2));
listOfSquares.add(BigInteger.valueOf(533000401).multiply(BigInteger.valueOf(982451653)).pow(2));
listOfSquares.add(BigInteger.valueOf(11).multiply(BigInteger.valueOf(23)));
listOfSquares.add(BigInteger.valueOf(11).multiply(BigInteger.valueOf(23)).pow(2));
for (BigInteger bigIntegerNumber : listOfSquares) {
BigInteger squareRoot = calculateSquareRoot(bigIntegerNumber);
System.out.println("Result :"+bigIntegerNumber+":"+squareRoot);
}
System.out.println("*********************************************************************");
for (BigInteger bigIntegerNumber : listOfSquares) {
BigInteger squareRoot = determineClosestWholeNumberSquareRoot(bigIntegerNumber);
System.out.println("Result :"+bigIntegerNumber+":"+squareRoot);
}
}
/*
Result :625:25
Result :14641:121
Result :23981286414105556927200571609:154858924231397
Result :274206311533451346298141971207799609:523647125012112853
Result :253:null
Result :64009:253
*/
public static BigInteger calculateSquareRoot(BigInteger number) {
/*
* Can be optimized by passing a bean to store the comparison result and avoid having to re-calculate.
*/
BigInteger squareRootResult = determineClosestWholeNumberSquareRoot(number);
if( squareRootResult.pow(2).equals(number)) {
return squareRootResult;
}
return null;
}
/*
Result :625:25
Result :14641:121
Result :23981286414105556927200571609:154858924231397
Result :274206311533451346298141971207799609:523647125012112853
Result :253:15
Result :64009:253
*/
private static BigInteger determineClosestWholeNumberSquareRoot(BigInteger number) {
BigInteger result = null;
if(number.equals(BigInteger.ONE)) {
return BigInteger.ONE;
} else if( number.equals(BigInteger.valueOf(2)) ) {
return BigInteger.ONE;
} else if( number.equals(BigInteger.valueOf(3)) ) {
return BigInteger.ONE;
} else if( number.equals(BigInteger.valueOf(4)) ) {
return BigInteger.valueOf(2);
}
BigInteger tempBaseLow = BigInteger.valueOf(2);
BigInteger tempBaseHigh = number.shiftRight(1); // divide by 2
int loopCount = 11;
while(true) {
if( tempBaseHigh.subtract(tempBaseLow).compareTo(BigInteger.valueOf(loopCount)) == -1 ) { // for lower numbers use for-loop
//System.out.println("Breaking out of while-loop.."); // uncomment-for-debugging
break;
}
BigInteger tempBaseMid = tempBaseHigh.subtract(tempBaseLow).shiftRight(1).add(tempBaseLow); // effectively mid = [(high-low)/2]+low
BigInteger tempBaseMidSquared = tempBaseMid.pow(2);
int comparisonResultTemp = tempBaseMidSquared.compareTo(number);
if(comparisonResultTemp == -1) { // move mid towards higher number
tempBaseLow = tempBaseMid;
} else if( comparisonResultTemp == 0 ) { // number is a square ! return the same !
return tempBaseMid;
} else { // move mid towards lower number
tempBaseHigh = tempBaseMid;
}
}
BigInteger tempBasePrevious = tempBaseLow;
BigInteger tempBaseCurrent = tempBaseLow;
for(int i=0;i<(loopCount+1);i++) {
BigInteger tempBaseSquared = tempBaseCurrent.pow(2);
//System.out.println("Squared :"+tempBaseSquared); // uncomment-for-debugging
int comparisonResultTempTwo = tempBaseSquared.compareTo(number);
if( comparisonResultTempTwo == -1 ) { // move current to previous and increment current...
tempBasePrevious = tempBaseCurrent;
tempBaseCurrent = tempBaseCurrent.add(BigInteger.ONE);
} else if( comparisonResultTempTwo == 0 ) { // is an exact match!
tempBasePrevious = tempBaseCurrent;
break;
} else { // we've identified the point of deviation.. break..
//System.out.println("breaking out of for-loop for square root..."); // uncomment-for-debugging
break;
}
}
result = tempBasePrevious;
//System.out.println("Returning :"+result); // uncomment-for-debugging
return result;
}
}
안부 라빈드라
한 줄이면 내가 생각하는 일을 할 수 있습니다.
Math.pow(bigInt.doubleValue(), (1/n));
ReferenceURL : https://stackoverflow.com/questions/4407839/how-can-i-find-the-square-root-of-a-java-biginteger
반응형
'IT이야기' 카테고리의 다른 글
| name()과 local-name()의 차이점 (0) | 2021.10.24 |
|---|---|
| 비 활동 클래스에서 getSystemService를 사용하는 방법 (0) | 2021.10.24 |
| 브라우저가 파일을 다운로드하도록 강제하는 방법 (0) | 2021.10.23 |
| JavaScript는 단일 스레드이므로 HTML5의 웹 작업자 다중 스레드 (0) | 2021.10.23 |
| 언제 cudaDeviceSynchronize를 호출 (0) | 2021.10.23 |