Bir longdeğerin mükemmel bir kare olup olmadığını belirlemek için en hızlı yolu arıyorum (yani onun kare kökü başka bir tamsayı):

1. Yerleşik Math.sqrt() işlevi kullanarak bunu kolay bir şekilde yaptım , ancak kendinizi yalnızca tamsayı alanıyla kısıtlayarak daha hızlı yapmanın bir yolu olup olmadığını merak ediyorum.
2. Bir arama tablosunu korumak pratik değildir (çünkü karesi 2 ^63'ten küçük olan yaklaşık 2 ^31.5 tamsayı vardır ).

İşte şimdi bunu yapmanın çok basit ve anlaşılır yolu:

public final static boolean isPerfectSquare(long n)
{
  if (n < 0)
    return false;

  long tst = (long)(Math.sqrt(n) + 0.5);
  return tst*tst == n;
}

_{Not: Bu işlevi birçok Project Euler probleminde kullanıyorum. Bu yüzden hiç kimse bu kodu korumak zorunda kalmayacak. Ve bu tür bir mikro optimizasyon aslında bir fark yaratabilir, çünkü zorluğun bir kısmı her algoritmayı bir dakikadan daha kısa sürede yapmaktır ve bu fonksiyonun bazı problemlerde milyonlarca kez çağrılması gerekecektir.}

Soruna farklı çözümler denedim:

• Kapsamlı testlerden sonra 0.5, en azından makinemde Math.sqrt () sonucuna eklemenin gerekli olmadığını gördüm.
• Kare kökü ters hızlı hızlı, ama yanlış sonuçlar verdi n> = 410881. Ancak önerdiği gibi BobbyShaftoe , biz n <410.881 için FISR kesmek kullanabilirsiniz.
• Newton'un yöntemi bundan biraz daha yavaştı Math.sqrt(). Muhtemelen Math.sqrt()Newton Metoduna benzer bir şey kullanıyor, ancak donanımda uygulandığı için Java'dan çok daha hızlı. Ayrıca, Newton'un Metodu hala çiftlerin kullanılmasını gerektiriyordu.
• Sadece tamsayı matematik dahil, birkaç hileler kullanılan değiştirilmiş Newton yöntemi, taşma önlemek için bazı kesmek gerekli (Ben bu işlevin tüm pozitif 64-bit işaretli tamsayılarla çalışmak istiyorum) ve hala daha yavaştı Math.sqrt().
• İkili pirzola daha yavaştı. İkili pirzola 64 bitlik bir sayının kare kökünü bulmak için ortalama 16 geçiş gerektireceğinden bu mantıklıdır.
• John'un testlerine göre, orifadeleri kullanmak C ++ 'da a kullanmaktan daha hızlıdır switch, ancak Java ve C #' da orve arasında hiçbir fark yoktur switch.
• Ayrıca bir arama tablosu (64 boolean özel bir statik dizi olarak) yapmaya çalıştım. Sonra ya anahtar ya da orifade yerine, sadece söyleyebilirim if(lookup[(int)(n&0x3F)]) { test } else return false;. Şaşırtıcı bir şekilde, bu (sadece biraz) daha yavaştı. Bunun nedeni dizi sınırlarının Java'da işaretlenmiş olmasıdır .

En azından CPU'm (x86) ve programlama dili (C / C ++) ile 6 bit + Carmack + sqrt kodundan ~% 35 daha hızlı çalışan bir yöntem buldum. Sonuçlarınız değişebilir, özellikle de Java faktörünün nasıl oynayacağını bilmiyorum.

Benim yaklaşımım üç yönlü:

1. İlk olarak, bariz cevapları filtreleyin. Buna negatif sayılar ve son 4 bite bakmak da dahildir. (Son altıya baktığımda yardım etmedim.) Ayrıca 0 için evet yanıtı verdim. (Aşağıdaki kodu okurken, girişimin olduğunu unutmayın int64 x.)

   if( x < 0 || (x&2) || ((x & 7) == 5) || ((x & 11) == 8) )
       return false;
   if( x == 0 )
       return true;

2. Sonra, bunun kare modü 255 = 3 * 5 * 17 olup olmadığını kontrol edin. Bu, üç ayrı primerin bir ürünü olduğundan, 255 mod kalıntılarının sadece 1 / 8'i karedir. Ancak, tecrübelerime göre, modulo operatörünü (%) çağırmak bir faydadan daha pahalıya mal oluyor, bu yüzden kalıntıyı hesaplamak için 255 = 2 ^ 8-1 içeren bit hileleri kullanıyorum. (Daha iyisi ya da daha kötüsü, tek bir baytın tek bir bayttan okunma hilesi kullanmıyorum, sadece bitsel ve ve vardiya.)

   int64 y = x;
   y = (y & 4294967295LL) + (y >> 32); 
   y = (y & 65535) + (y >> 16);
   y = (y & 255) + ((y >> 8) & 255) + (y >> 16);
   // At this point, y is between 0 and 511.  More code can reduce it farther.

   Artığın bir kare olup olmadığını gerçekten kontrol etmek için, cevabı önceden hesaplanmış bir tabloda ararım.

   if( bad255[y] )
       return false;
   // However, I just use a table of size 512

3. Son olarak, kare kökünü Hensel lemmasına benzer bir yöntem kullanarak hesaplamaya çalışın . (Doğrudan uygulanabilir olduğunu düşünmüyorum, ancak bazı değişikliklerle çalışıyor.) Bunu yapmadan önce, 2'nin tüm güçlerini ikili bir arama ile bölüyorum:

   if((x & 4294967295LL) == 0)
       x >>= 32;
   if((x & 65535) == 0)
       x >>= 16;
   if((x & 255) == 0)
       x >>= 8;
   if((x & 15) == 0)
       x >>= 4;
   if((x & 3) == 0)
       x >>= 2;

   Bu noktada, sayımızın kare olması için 1 mod 8 olmalıdır.

   if((x & 7) != 1)
       return false;

   Hensel lemmasının temel yapısı şöyledir. (Not: test edilmemiş kod; çalışmazsa t = 2 veya 8'i deneyin.)

   int64 t = 4, r = 1;
   t <<= 1; r += ((x - r * r) & t) >> 1;
   t <<= 1; r += ((x - r * r) & t) >> 1;
   t <<= 1; r += ((x - r * r) & t) >> 1;
   // Repeat until t is 2^33 or so.  Use a loop if you want.

   Fikir, her yinelemede, x'in "geçerli" kare kökü olan r'ye bir bit eklediğinizdir; her kare kök doğru modülo 2 daha büyük ve daha büyük bir güç, yani t / 2. Sonunda, r ve t / 2-r x modulo t / 2'nin kare kökleri olacaktır. (Eğer r, x'in karekökü ise, o zaman -r'dir. Bu bile modulo sayılarıdır, ancak bazı sayıları modulo'ya dikkat edin, her şeyin 2'den fazla kare kökü olabileceğine dikkat edin; özellikle 2'nin gücünü içerir. ) Gerçek kare kökümüz 2 ^ 32'den az olduğu için, bu noktada aslında r veya t / 2-r'nin gerçek kare kökleri olup olmadığını kontrol edebiliriz. Benim gerçek kod, aşağıdaki değiştirilmiş döngü kullanın:

   int64 r, t, z;
   r = start[(x >> 3) & 1023];
   do {
       z = x - r * r;
       if( z == 0 )
           return true;
       if( z < 0 )
           return false;
       t = z & (-z);
       r += (z & t) >> 1;
       if( r > (t >> 1) )
           r = t - r;
   } while( t <= (1LL << 33) );

   Buradaki hız üç şekilde elde edilir: önceden hesaplanmış başlangıç ​​değeri (döngünün ~ 10 tekrarına eşdeğer), döngünün erken çıkışı ve bazı t değerlerini atlama. Son kısımda, bakıyorum z = r - x * xve t'yi 2 bölünme z'nin biraz hile ile en büyük gücü olarak ayarladım. Bu zaten r değerini etkilemeyecek t değerlerini atlamama izin veriyor. Benim durumumda önceden hesaplanmış başlangıç ​​değeri "en küçük pozitif" kare kök modulo 8192 alır.

Bu kod sizin için daha hızlı çalışmıyor olsa bile, umarım içerdiği bazı fikirlerden keyif alırsınız. Önceden hesaplanmış tablolar da dahil olmak üzere eksiksiz, test edilmiş kod aşağıdaki gibidir.

typedef signed long long int int64;

int start[1024] =
{1,3,1769,5,1937,1741,7,1451,479,157,9,91,945,659,1817,11,
1983,707,1321,1211,1071,13,1479,405,415,1501,1609,741,15,339,1703,203,
129,1411,873,1669,17,1715,1145,1835,351,1251,887,1573,975,19,1127,395,
1855,1981,425,453,1105,653,327,21,287,93,713,1691,1935,301,551,587,
257,1277,23,763,1903,1075,1799,1877,223,1437,1783,859,1201,621,25,779,
1727,573,471,1979,815,1293,825,363,159,1315,183,27,241,941,601,971,
385,131,919,901,273,435,647,1493,95,29,1417,805,719,1261,1177,1163,
1599,835,1367,315,1361,1933,1977,747,31,1373,1079,1637,1679,1581,1753,1355,
513,1539,1815,1531,1647,205,505,1109,33,1379,521,1627,1457,1901,1767,1547,
1471,1853,1833,1349,559,1523,967,1131,97,35,1975,795,497,1875,1191,1739,
641,1149,1385,133,529,845,1657,725,161,1309,375,37,463,1555,615,1931,
1343,445,937,1083,1617,883,185,1515,225,1443,1225,869,1423,1235,39,1973,
769,259,489,1797,1391,1485,1287,341,289,99,1271,1701,1713,915,537,1781,
1215,963,41,581,303,243,1337,1899,353,1245,329,1563,753,595,1113,1589,
897,1667,407,635,785,1971,135,43,417,1507,1929,731,207,275,1689,1397,
1087,1725,855,1851,1873,397,1607,1813,481,163,567,101,1167,45,1831,1205,
1025,1021,1303,1029,1135,1331,1017,427,545,1181,1033,933,1969,365,1255,1013,
959,317,1751,187,47,1037,455,1429,609,1571,1463,1765,1009,685,679,821,
1153,387,1897,1403,1041,691,1927,811,673,227,137,1499,49,1005,103,629,
831,1091,1449,1477,1967,1677,697,1045,737,1117,1737,667,911,1325,473,437,
1281,1795,1001,261,879,51,775,1195,801,1635,759,165,1871,1645,1049,245,
703,1597,553,955,209,1779,1849,661,865,291,841,997,1265,1965,1625,53,
1409,893,105,1925,1297,589,377,1579,929,1053,1655,1829,305,1811,1895,139,
575,189,343,709,1711,1139,1095,277,993,1699,55,1435,655,1491,1319,331,
1537,515,791,507,623,1229,1529,1963,1057,355,1545,603,1615,1171,743,523,
447,1219,1239,1723,465,499,57,107,1121,989,951,229,1521,851,167,715,
1665,1923,1687,1157,1553,1869,1415,1749,1185,1763,649,1061,561,531,409,907,
319,1469,1961,59,1455,141,1209,491,1249,419,1847,1893,399,211,985,1099,
1793,765,1513,1275,367,1587,263,1365,1313,925,247,1371,1359,109,1561,1291,
191,61,1065,1605,721,781,1735,875,1377,1827,1353,539,1777,429,1959,1483,
1921,643,617,389,1809,947,889,981,1441,483,1143,293,817,749,1383,1675,
63,1347,169,827,1199,1421,583,1259,1505,861,457,1125,143,1069,807,1867,
2047,2045,279,2043,111,307,2041,597,1569,1891,2039,1957,1103,1389,231,2037,
65,1341,727,837,977,2035,569,1643,1633,547,439,1307,2033,1709,345,1845,
1919,637,1175,379,2031,333,903,213,1697,797,1161,475,1073,2029,921,1653,
193,67,1623,1595,943,1395,1721,2027,1761,1955,1335,357,113,1747,1497,1461,
1791,771,2025,1285,145,973,249,171,1825,611,265,1189,847,1427,2023,1269,
321,1475,1577,69,1233,755,1223,1685,1889,733,1865,2021,1807,1107,1447,1077,
1663,1917,1129,1147,1775,1613,1401,555,1953,2019,631,1243,1329,787,871,885,
449,1213,681,1733,687,115,71,1301,2017,675,969,411,369,467,295,693,
1535,509,233,517,401,1843,1543,939,2015,669,1527,421,591,147,281,501,
577,195,215,699,1489,525,1081,917,1951,2013,73,1253,1551,173,857,309,
1407,899,663,1915,1519,1203,391,1323,1887,739,1673,2011,1585,493,1433,117,
705,1603,1111,965,431,1165,1863,533,1823,605,823,1179,625,813,2009,75,
1279,1789,1559,251,657,563,761,1707,1759,1949,777,347,335,1133,1511,267,
833,1085,2007,1467,1745,1805,711,149,1695,803,1719,485,1295,1453,935,459,
1151,381,1641,1413,1263,77,1913,2005,1631,541,119,1317,1841,1773,359,651,
961,323,1193,197,175,1651,441,235,1567,1885,1481,1947,881,2003,217,843,
1023,1027,745,1019,913,717,1031,1621,1503,867,1015,1115,79,1683,793,1035,
1089,1731,297,1861,2001,1011,1593,619,1439,477,585,283,1039,1363,1369,1227,
895,1661,151,645,1007,1357,121,1237,1375,1821,1911,549,1999,1043,1945,1419,
1217,957,599,571,81,371,1351,1003,1311,931,311,1381,1137,723,1575,1611,
767,253,1047,1787,1169,1997,1273,853,1247,413,1289,1883,177,403,999,1803,
1345,451,1495,1093,1839,269,199,1387,1183,1757,1207,1051,783,83,423,1995,
639,1155,1943,123,751,1459,1671,469,1119,995,393,219,1743,237,153,1909,
1473,1859,1705,1339,337,909,953,1771,1055,349,1993,613,1393,557,729,1717,
511,1533,1257,1541,1425,819,519,85,991,1693,503,1445,433,877,1305,1525,
1601,829,809,325,1583,1549,1991,1941,927,1059,1097,1819,527,1197,1881,1333,
383,125,361,891,495,179,633,299,863,285,1399,987,1487,1517,1639,1141,
1729,579,87,1989,593,1907,839,1557,799,1629,201,155,1649,1837,1063,949,
255,1283,535,773,1681,461,1785,683,735,1123,1801,677,689,1939,487,757,
1857,1987,983,443,1327,1267,313,1173,671,221,695,1509,271,1619,89,565,
127,1405,1431,1659,239,1101,1159,1067,607,1565,905,1755,1231,1299,665,373,
1985,701,1879,1221,849,627,1465,789,543,1187,1591,923,1905,979,1241,181};

bool bad255[512] =
{0,0,1,1,0,1,1,1,1,0,1,1,1,1,1,0,0,1,1,0,1,0,1,1,1,0,1,1,1,1,0,1,
 1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,0,1,1,1,
 0,1,0,1,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,1,1,1,1,0,1,
 1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,
 1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,
 1,1,1,1,1,1,0,1,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,
 1,1,1,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,
 1,0,1,1,1,0,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,
 0,0,1,1,0,1,1,1,1,0,1,1,1,1,1,0,0,1,1,0,1,0,1,1,1,0,1,1,1,1,0,1,
 1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,0,1,1,1,
 0,1,0,1,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,1,1,1,1,0,1,
 1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,
 1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,
 1,1,1,1,1,1,0,1,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,
 1,1,1,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,
 1,0,1,1,1,0,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,
 0,0};

inline bool square( int64 x ) {
    // Quickfail
    if( x < 0 || (x&2) || ((x & 7) == 5) || ((x & 11) == 8) )
        return false;
    if( x == 0 )
        return true;

    // Check mod 255 = 3 * 5 * 17, for fun
    int64 y = x;
    y = (y & 4294967295LL) + (y >> 32);
    y = (y & 65535) + (y >> 16);
    y = (y & 255) + ((y >> 8) & 255) + (y >> 16);
    if( bad255[y] )
        return false;

    // Divide out powers of 4 using binary search
    if((x & 4294967295LL) == 0)
        x >>= 32;
    if((x & 65535) == 0)
        x >>= 16;
    if((x & 255) == 0)
        x >>= 8;
    if((x & 15) == 0)
        x >>= 4;
    if((x & 3) == 0)
        x >>= 2;

    if((x & 7) != 1)
        return false;

    // Compute sqrt using something like Hensel's lemma
    int64 r, t, z;
    r = start[(x >> 3) & 1023];
    do {
        z = x - r * r;
        if( z == 0 )
            return true;
        if( z < 0 )
            return false;
        t = z & (-z);
        r += (z & t) >> 1;
        if( r > (t  >> 1) )
            r = t - r;
    } while( t <= (1LL << 33) );

    return false;
}

Partiye oldukça geç kaldım, ancak daha iyi bir cevap vermeyi umuyorum; daha kısa ve ( karşılaştırmamın doğru olduğunu varsayarak ) çok daha hızlı .

long goodMask; // 0xC840C04048404040 computed below
{
    for (int i=0; i<64; ++i) goodMask |= Long.MIN_VALUE >>> (i*i);
}

public boolean isSquare(long x) {
    // This tests if the 6 least significant bits are right.
    // Moving the to be tested bit to the highest position saves us masking.
    if (goodMask << x >= 0) return false;
    final int numberOfTrailingZeros = Long.numberOfTrailingZeros(x);
    // Each square ends with an even number of zeros.
    if ((numberOfTrailingZeros & 1) != 0) return false;
    x >>= numberOfTrailingZeros;
    // Now x is either 0 or odd.
    // In binary each odd square ends with 001.
    // Postpone the sign test until now; handle zero in the branch.
    if ((x&7) != 1 | x <= 0) return x == 0;
    // Do it in the classical way.
    // The correctness is not trivial as the conversion from long to double is lossy!
    final long tst = (long) Math.sqrt(x);
    return tst * tst == x;
}

İlk test karelerin çoğunu hızlı bir şekilde yakalar. Uzun süredir paketlenmiş 64 maddelik bir tablo kullanır, bu nedenle dizi erişim maliyeti yoktur (dolaylı ve sınır kontrolleri). Eşit olarak rasgele için long, burada bitirme olasılığı% 81.25'dir.

İkinci test, çarpanlarına ayırmada tek sayıda ikişer ikişer sayıyı yakalar. Yöntem Long.numberOfTrailingZeros, JIT-ed'i tek bir i86 komutuna aldığından çok hızlıdır.

Sondaki sıfırları bıraktıktan sonra, üçüncü test 011, 101 veya 111 ile biten sayıları ikili kareler halinde işler, ki bunlar mükemmel kareler değildir. Ayrıca negatif sayıları da önemsiyor ve 0 ile de ilgileniyor.

Son test doublearitmetiğe düşer . Olarak doublesadece 53 bit mantis, dönüşüm vardır longiçin doublebüyük değerler için yuvarlama içerir. Bununla birlikte, test doğrudur ( kanıt yanlış olmadığı sürece ).

Mod255 fikrini birleştirmeye çalışmak başarılı olmadı.

Bazı kıyaslamalar yapmanız gerekecek. En iyi algoritma, girdilerinizin dağıtımına bağlıdır.

Algoritmanız neredeyse optimal olabilir, ancak karekök rutininizi çağırmadan önce bazı olasılıkları göz ardı etmek için hızlı bir kontrol yapmak isteyebilirsiniz. Örneğin, numaranızın son basamağına onaltılık bir sayı olarak "ve." Mükemmel kareler sadece taban 16'da 0, 1, 4 veya 9 ile bitebilir, bu nedenle girişlerinizin% 75'i için (eşit olarak dağıtıldıkları varsayılarak), çok hızlı bit twiddling karşılığında kare kökü çağırmaktan kaçınabilirsiniz.

Kip, altıgen numarayı uygulayan aşağıdaki kodu karşılaştırdı. 1 ile 100.000.000 arasındaki sayıları test ederken, bu kod orijinalinden iki kat daha hızlı çalışıyordu.

public final static boolean isPerfectSquare(long n)
{
    if (n < 0)
        return false;

    switch((int)(n & 0xF))
    {
    case 0: case 1: case 4: case 9:
        long tst = (long)Math.sqrt(n);
        return tst*tst == n;

    default:
        return false;
    }
}

C ++ 'da benzer kodu test ettiğimde, aslında orijinalinden daha yavaş koştu. Ancak, switch deyimini ortadan kaldırdığımda, hex hile bir kez daha kodu iki kat daha hızlı hale getirir.

int isPerfectSquare(int n)
{
    int h = n & 0xF;  // h is the last hex "digit"
    if (h > 9)
        return 0;
    // Use lazy evaluation to jump out of the if statement as soon as possible
    if (h != 2 && h != 3 && h != 5 && h != 6 && h != 7 && h != 8)
    {
        int t = (int) floor( sqrt((double) n) + 0.5 );
        return t*t == n;
    }
    return 0;
}

Switch ifadesinin kaldırılmasının C # kodu üzerinde çok az etkisi oldu.

Sayısal Analiz dersinde geçirdiğim korkunç zamanları düşünüyordum.

Ve sonra hatırlıyorum, Quake Source kodundan 'net etrafında dönen bu fonksiyon vardı:

float Q_rsqrt( float number )
{
  long i;
  float x2, y;
  const float threehalfs = 1.5F;

  x2 = number * 0.5F;
  y  = number;
  i  = * ( long * ) &y;  // evil floating point bit level hacking
  i  = 0x5f3759df - ( i >> 1 ); // wtf?
  y  = * ( float * ) &i;
  y  = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
  // y  = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

  #ifndef Q3_VM
  #ifdef __linux__
    assert( !isnan(y) ); // bk010122 - FPE?
  #endif
  #endif
  return y;
}

Hangi temelde bir kare kök, Newton'un yaklaşık işlevini kullanarak hesaplar (tam adı hatırlayamıyorum).

Kullanılabilir olmalı ve hatta daha hızlı olabilir, olağanüstü kimlik yazılımı oyunlarından birinden!

C ++ ile yazılmıştır, ancak fikri aldıktan sonra aynı tekniği Java'da tekrar kullanmak çok zor olmamalıdır:

Başlangıçta buldum: http://www.codemaestro.com/reviews/9

Newton yöntemi wikipedia'da açıklanmıştır: http://en.wikipedia.org/wiki/Newton%27s_method

Nasıl çalıştığına dair daha fazla açıklama için bağlantıyı takip edebilirsiniz, ancak çok fazla umursamıyorsanız, blog'u okurken ve Sayısal Analiz kursunu almaktan hatırladığım şey kabaca budur:

• * (long*) &ytemelde tamsayı işlemleri ham bayt uygulanabilir, böylece hızlı dönüştürme-uzun işlevdir.
• 0x5f3759df - (i >> 1);Yaklaşım fonksiyon için önceden hesaplanan tohum değerdir.
• * (float*) &iKayan nokta değeri geri dönüştürür.
• y = y * ( threehalfs - ( x2 * y * y ) )çizgi çağrısının tekrar fonksiyonu üzerinde bir değer dolaşır.

Yaklaştırma işlevi, sonuç üzerinde işlevi yinelediğinizde daha kesin değerler verir. Quake'in durumunda, bir yineleme "yeterince iyi" dir, ancak sizin için uygun değilse ... o zaman ihtiyacınız kadar yineleme ekleyebilirsiniz.

Bu daha hızlı olmalıdır, çünkü saf karekök işleminde yapılan bölme işlemlerinin sayısını 2'ye basit bir bölmeye (aslında * 0.5Fçarpma işlemi) indirir ve bunun yerine birkaç sabit sayıda çarpma işlemiyle değiştirir.

Daha hızlı mı yoksa daha doğru mı olacağından emin değilim, ancak karekökünü daha hızlı çözmek için John Carmack'in Sihirli Kare Kökü algoritmasını kullanabilirsiniz. Muhtemelen bunu tüm olası 32 bit tamsayılar için test edebilir ve sadece bir tayin olduğu için doğru sonuçlara sahip olduğunuzu doğrulayabilirsiniz. Ancak, şimdi düşündüğümde, çiftleri kullanmak da yaklaşıyor, bu yüzden bunun nasıl oynayacağından emin değilim.

"Doğru" kare kökü bulmaya çalışmak için bir ikili kesme yaparsanız, sahip olduğunuz değerin anlatacak kadar yakın olup olmadığını kolayca tespit edebilirsiniz:

(n+1)^2 = n^2 + 2n + 1
(n-1)^2 = n^2 - 2n + 1

Yani hesapladıktan n^2sonra, seçenekler şunlardır:

• n^2 = target: bitti, geri dön
• n^2 + 2n + 1 > target > n^2 : yakınsın, ama mükemmel değil: yanlış döndür
• n^2 - 2n + 1 < target < n^2 : aynen
• target < n^2 - 2n + 1 : bir altta ikili pirzola n
• target > n^2 + 2n + 1 : daha yüksek bir ikili pirzola n

(Üzgünüz, bu nmevcut tahmininiz ve targetparametre için kullanılır. Karışıklık için özür dileriz !)

Bunun daha hızlı olup olmayacağını bilmiyorum, ama denemeye değer.

DÜZENLEME: İkili pirzola, tam sayı aralığını da almak zorunda değildir (2^x)^2 = 2^(2x), bu nedenle hedefinizde en iyi set bitini bulduktan sonra (bu, biraz dönen bir numara ile yapılabilir; nasıl olduğunu tamamen unuttum) hızlıca bir dizi potansiyel cevap alabilirsiniz. Dikkat edin, saf bir ikili pirzola hala sadece 31 veya 32 yineleme alacaktır.

Bu iş parçacığındaki algoritmaların birkaçını kendi analizimi yaptım ve bazı yeni sonuçlar elde ettim. Bu eski sonuçları bu cevabın düzenleme geçmişinde görebilirsiniz, ancak bir hata yaptığım gibi doğru değiller ve yakın olmayan birkaç algoritmayı analiz etmek için zaman harcadık. Ancak, birkaç farklı cevap dersleri çekerek, şimdi bu iş parçacığının "kazanan" ezmek iki algoritmalar var. İşte herkesten farklı yaptığım temel şey:

// This is faster because a number is divisible by 2^4 or more only 6% of the time
// and more than that a vanishingly small percentage.
while((x & 0x3) == 0) x >>= 2;
// This is effectively the same as the switch-case statement used in the original
// answer. 
if((x & 0x7) != 1) return false;

Bununla birlikte, çoğu zaman bir veya iki çok hızlı talimat ekleyen bu basit satır, switch-caseifadeyi bir if ifadesine büyük ölçüde basitleştirir . Bununla birlikte, test edilen sayıların çoğunda önemli iki güç faktörü varsa çalışma zamanına eklenebilir.

Aşağıdaki algoritmalar aşağıdaki gibidir:

• İnternet - Kip'in cevabı gönderildi
• Durron - Tek geçişli cevabı temel olarak kullanarak değiştirilmiş cevabım
• DurronTwo - Diğer bazı küçük değişikliklerle iki geçişli cevabı (@JohnnyHeggheim tarafından) kullanarak değiştirilmiş cevabım.

Sayılar kullanılarak oluşturulmuşsa örnek bir çalışma zamanı Math.abs(java.util.Random.nextLong())

 0% Scenario{vm=java, trial=0, benchmark=Internet} 39673.40 ns; ?=378.78 ns @ 3 trials
33% Scenario{vm=java, trial=0, benchmark=Durron} 37785.75 ns; ?=478.86 ns @ 10 trials
67% Scenario{vm=java, trial=0, benchmark=DurronTwo} 35978.10 ns; ?=734.10 ns @ 10 trials

benchmark   us linear runtime
 Internet 39.7 ==============================
   Durron 37.8 ============================
DurronTwo 36.0 ===========================

vm: java
trial: 0

Ve sadece ilk milyon uzunluğunda çalıştırılırsa örnek bir çalışma zamanı:

 0% Scenario{vm=java, trial=0, benchmark=Internet} 2933380.84 ns; ?=56939.84 ns @ 10 trials
33% Scenario{vm=java, trial=0, benchmark=Durron} 2243266.81 ns; ?=50537.62 ns @ 10 trials
67% Scenario{vm=java, trial=0, benchmark=DurronTwo} 3159227.68 ns; ?=10766.22 ns @ 3 trials

benchmark   ms linear runtime
 Internet 2.93 ===========================
   Durron 2.24 =====================
DurronTwo 3.16 ==============================

vm: java
trial: 0

Gördüğünüz gibi, DurronTwobüyük girdiler için daha iyisini yapar, çünkü sihir numarasını çok sık kullanır, ancak ilk algoritmaya kıyasla ve Math.sqrtsayılar çok daha küçük olduğu için hızlanır. Bu arada, daha basit Durronbüyük bir kazanan çünkü ilk milyon sayısında asla birçok kez 4'e bölmek zorunda değil.

İşte Durron:

public final static boolean isPerfectSquareDurron(long n) {
    if(n < 0) return false;
    if(n == 0) return true;

    long x = n;
    // This is faster because a number is divisible by 16 only 6% of the time
    // and more than that a vanishingly small percentage.
    while((x & 0x3) == 0) x >>= 2;
    // This is effectively the same as the switch-case statement used in the original
    // answer. 
    if((x & 0x7) == 1) {

        long sqrt;
        if(x < 410881L)
        {
            int i;
            float x2, y;

            x2 = x * 0.5F;
            y  = x;
            i  = Float.floatToRawIntBits(y);
            i  = 0x5f3759df - ( i >> 1 );
            y  = Float.intBitsToFloat(i);
            y  = y * ( 1.5F - ( x2 * y * y ) );

            sqrt = (long)(1.0F/y);
        } else {
            sqrt = (long) Math.sqrt(x);
        }
        return sqrt*sqrt == x;
    }
    return false;
}

Ve DurronTwo

public final static boolean isPerfectSquareDurronTwo(long n) {
    if(n < 0) return false;
    // Needed to prevent infinite loop
    if(n == 0) return true;

    long x = n;
    while((x & 0x3) == 0) x >>= 2;
    if((x & 0x7) == 1) {
        long sqrt;
        if (x < 41529141369L) {
            int i;
            float x2, y;

            x2 = x * 0.5F;
            y = x;
            i = Float.floatToRawIntBits(y);
            //using the magic number from 
            //http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf
            //since it more accurate
            i = 0x5f375a86 - (i >> 1);
            y = Float.intBitsToFloat(i);
            y = y * (1.5F - (x2 * y * y));
            y = y * (1.5F - (x2 * y * y)); //Newton iteration, more accurate
            sqrt = (long) ((1.0F/y) + 0.2);
        } else {
            //Carmack hack gives incorrect answer for n >= 41529141369.
            sqrt = (long) Math.sqrt(x);
        }
        return sqrt*sqrt == x;
    }
    return false;
}

Ve karşılaştırmalı değerlendirme kayışım: (Google kaliper 0.1-rc5 gerektirir)

public class SquareRootBenchmark {
    public static class Benchmark1 extends SimpleBenchmark {
        private static final int ARRAY_SIZE = 10000;
        long[] trials = new long[ARRAY_SIZE];

        @Override
        protected void setUp() throws Exception {
            Random r = new Random();
            for (int i = 0; i < ARRAY_SIZE; i++) {
                trials[i] = Math.abs(r.nextLong());
            }
        }


        public int timeInternet(int reps) {
            int trues = 0;
            for(int i = 0; i < reps; i++) {
                for(int j = 0; j < ARRAY_SIZE; j++) {
                    if(SquareRootAlgs.isPerfectSquareInternet(trials[j])) trues++;
                }
            }

            return trues;   
        }

        public int timeDurron(int reps) {
            int trues = 0;
            for(int i = 0; i < reps; i++) {
                for(int j = 0; j < ARRAY_SIZE; j++) {
                    if(SquareRootAlgs.isPerfectSquareDurron(trials[j])) trues++;
                }
            }

            return trues;   
        }

        public int timeDurronTwo(int reps) {
            int trues = 0;
            for(int i = 0; i < reps; i++) {
                for(int j = 0; j < ARRAY_SIZE; j++) {
                    if(SquareRootAlgs.isPerfectSquareDurronTwo(trials[j])) trues++;
                }
            }

            return trues;   
        }
    }

    public static void main(String... args) {
        Runner.main(Benchmark1.class, args);
    }
}

GÜNCELLEME: Bazı senaryolarda daha hızlı, diğerlerinde daha yavaş yeni bir algoritma yaptım, farklı girdilere dayalı farklı ölçütler aldım. Modulo hesaplarsak 0xFFFFFF = 3 x 3 x 5 x 7 x 13 x 17 x 241, kareler olamaz sayıların% 97.82'sini ortadan kaldırabiliriz. Bu, 5 bitsel işlemle bir satırda (bir çeşit) yapılabilir:

if (!goodLookupSquares[(int) ((n & 0xFFFFFFl) + ((n >> 24) & 0xFFFFFFl) + (n >> 48))]) return false;

Elde edilen indeks 1) tortu, 2) tortu + 0xFFFFFFveya 3) tortudur + 0x1FFFFFE. Tabii ki, 0xFFFFFF3mb dosyası hakkında kalıntı modulo için bir arama tablosuna ihtiyacımız var (bu durumda ascii metin ondalık sayıları olarak saklanır, optimal değil, ancak ByteBuffervb. kadar önemli t. burada dosyayı bulabilirsiniz (veya kendiniz oluşturmak):

public final static boolean isPerfectSquareDurronThree(long n) {
    if(n < 0) return false;
    if(n == 0) return true;

    long x = n;
    while((x & 0x3) == 0) x >>= 2;
    if((x & 0x7) == 1) {
        if (!goodLookupSquares[(int) ((n & 0xFFFFFFl) + ((n >> 24) & 0xFFFFFFl) + (n >> 48))]) return false;
        long sqrt;
        if(x < 410881L)
        {
            int i;
            float x2, y;

            x2 = x * 0.5F;
            y  = x;
            i  = Float.floatToRawIntBits(y);
            i  = 0x5f3759df - ( i >> 1 );
            y  = Float.intBitsToFloat(i);
            y  = y * ( 1.5F - ( x2 * y * y ) );

            sqrt = (long)(1.0F/y);
        } else {
            sqrt = (long) Math.sqrt(x);
        }
        return sqrt*sqrt == x;
    }
    return false;
}

Ben böyle bir booleandiziye yüklemek :

private static boolean[] goodLookupSquares = null;

public static void initGoodLookupSquares() throws Exception {
    Scanner s = new Scanner(new File("24residues_squares.txt"));

    goodLookupSquares = new boolean[0x1FFFFFE];

    while(s.hasNextLine()) {
        int residue = Integer.valueOf(s.nextLine());
        goodLookupSquares[residue] = true;
        goodLookupSquares[residue + 0xFFFFFF] = true;
        goodLookupSquares[residue + 0x1FFFFFE] = true;
    }

    s.close();
}

Örnek çalışma zamanı. Çalıştığım Durronher denemede (sürüm bir) yendi .

 0% Scenario{vm=java, trial=0, benchmark=Internet} 40665.77 ns; ?=566.71 ns @ 10 trials
33% Scenario{vm=java, trial=0, benchmark=Durron} 38397.60 ns; ?=784.30 ns @ 10 trials
67% Scenario{vm=java, trial=0, benchmark=DurronThree} 36171.46 ns; ?=693.02 ns @ 10 trials

  benchmark   us linear runtime
   Internet 40.7 ==============================
     Durron 38.4 ============================
DurronThree 36.2 ==========================

vm: java
trial: 0

Tamsayı Karekökünü hesaplamak için Newton'un yöntemini kullanmak , daha sonra bu sayıyı kareye almak ve mevcut çözümünüzde yaptığınız gibi kontrol etmek çok daha hızlı olmalıdır . Newton'un yöntemi, diğer bazı cevaplarda bahsedilen Carmack çözümünün temelidir. Daha hızlı bir yanıt alabilmeniz gerekir, çünkü kökün tamsayı kısmı ile ilgilenirsiniz, bu da yaklaşık algoritmayı daha erken durdurmanıza izin verir.

Deneyebileceğiniz başka bir optimizasyon: Sayının Dijital Kökü 1, 4, 7 veya 9 ile bitmezse, sayı mükemmel bir kare değildir . Bu, daha yavaş karekök algoritmasını uygulamadan önce girişlerinizin% 60'ını ortadan kaldırmanın hızlı bir yolu olarak kullanılabilir.

Bu işlevin tüm pozitif 64 bit işaretli tamsayılarla çalışmasını istiyorum

Math.sqrt()giriş parametreleri olarak çiftlerle çalışır, bu nedenle 2 ^ 53'ten büyük tamsayılar için doğru sonuçlar elde edemezsiniz .

Sadece kayıt için, bir başka yaklaşım da ana ayrışmayı kullanmaktır. Ayrışmanın her faktörü eşitse, sayı mükemmel bir karedir. Yani istediğiniz bir sayı, asal sayıların karelerinin bir ürünü olarak ayrıştırılıp ayrıştırılamayacağını görmek. Tabii ki, böyle bir ayrışma elde etmenize gerek yok, sadece var olup olmadığını görmek için.

İlk önce 2 ^ 32'den küçük asal sayıların karelerinden oluşan bir tablo oluşturun. Bu, bu sınıra kadar olan tamsayıların bir tablosundan çok daha küçüktür.

Bir çözüm şu şekilde olur:

boolean isPerfectSquare(long number)
{
    if (number < 0) return false;
    if (number < 2) return true;

    for (int i = 0; ; i++)
    {
        long square = squareTable[i];
        if (square > number) return false;
        while (number % square == 0)
        {
            number /= square;
        }
        if (number == 1) return true;
    }
}

Sanırım biraz şifreli. Her adımda asal sayının karesinin giriş numarasını böldüğünü kontrol etmektir. Eğer öyleyse, sayıyı mümkün olduğu kadar kareye böler, bu kareyi asal ayrışmadan çıkarmak için. Bu işlemle 1'e geldiysek, girdi numarası asal sayıların karesinin bir ayrışmasıydı. Kare sayının kendisinden daha büyük olursa, bu karenin veya daha büyük karelerin bölebilmesi mümkün değildir, bu nedenle sayı asal sayıların karelerinin ayrıştırılması olamaz.

Günümüzde donanımda yapılan sqrt ve burada asal sayıları hesaplama ihtiyacı göz önüne alındığında, bu çözüm çok daha yavaş olduğunu düşünüyorum. Ancak cevabında mrzl'nin dediği gibi, 2 ^ 54 üzerinde çalışmayan sqrt çözümünden daha iyi sonuçlar vermelidir.

dMükemmel bir karenin son basamaklarının sadece belirli değerleri alabileceği belirtildi. Bir sayının son dbasamağı (tabandaki b) , bölündüğünde nkalanla aynıdır , yani. C gösterimindenbdn % pow(b, d) .

Bu herhangi bir modül için genelleştirilebilir m, yani.n % msayıların bazı yüzdelerinin mükemmel kareler olmasını engellemek için kullanılabilir. Şu anda kullandığınız modül 12'dir, bu da 12'ye izin verir, yani. Kalanların% 19'u, mümkün olduğunca kareler. Küçük bir kodlama ile, sadece 2016, yani izin veren 110880 modülünü buldum. Kalanların% 1.8'i mümkün olduğunca kareler. Bu nedenle, bir modül işleminin (yani bölüm) ve tablo aramasının makinenizdeki karekökü karşısında maliyetine bağlı olarak, bu modülü kullanmak daha hızlı olabilir.

Bu arada, Java'nın arama tablosu için paketlenmiş bir bit dizisini saklamanın bir yolu varsa, bunu kullanmayın. 110880 32-bit kelimeler bugünlerde çok fazla RAM değil ve bir makine kelimesini getirmek tek bir bit getirmekten daha hızlı olacak.

Bir tamsayı sorunu bir tamsayı çözümünü hak eder. Böylece

Bu şekilde en büyük tamsayıyı bulmak için (negatif olmayan) tamsayılarda ikili arama yapın t**2 <= n. Sonra r**2 = ntam olarak test edin . Bu zaman O (log n) alır.

Kümenin sınırsız olması nedeniyle pozitif tam sayıların ikili olarak nasıl aranacağını bilmiyorsanız, bu kolaydır. Artan fonksiyonunuzu f (yukarıda f(t) = t**2 - n) iki güç üzerinden hesaplayarak başlıyorsunuz . Pozitif olduğunu gördüğünüzde bir üst sınır buldunuz. Sonra standart ikili arama yapabilirsiniz.

Maaartinus'un çözümünün aşağıdaki basitleştirilmesi, çalışma süresinden birkaç yüzde puan alıyor gibi görünüyor, ancak güvenebileceğim bir karşılaştırma ölçütü oluşturmak için kıyaslamada yeterince iyi değilim:

long goodMask; // 0xC840C04048404040 computed below
{
    for (int i=0; i<64; ++i) goodMask |= Long.MIN_VALUE >>> (i*i);
}

public boolean isSquare(long x) {
    // This tests if the 6 least significant bits are right.
    // Moving the to be tested bit to the highest position saves us masking.
    if (goodMask << x >= 0) return false;
    // Remove an even number of trailing zeros, leaving at most one.
    x >>= (Long.numberOfTrailingZeros(x) & (-2);
    // Repeat the test on the 6 least significant remaining bits.
    if (goodMask << x >= 0 | x <= 0) return x == 0;
    // Do it in the classical way.
    // The correctness is not trivial as the conversion from long to double is lossy!
    final long tst = (long) Math.sqrt(x);
    return tst * tst == x;
}

İlk testi nasıl atladığınızı kontrol etmeye değer,

if (goodMask << x >= 0) return false;

performansı etkiler.

Performans için, çoğu zaman bazı uzlaşmalar yapmanız gerekir. Diğerleri çeşitli yöntemler ifade ettiler, ancak Carmack'in korsanlığının belirli N değerlerine kadar daha hızlı olduğunu fark ettiniz. Sonra, "n" yi kontrol etmelisiniz ve bu N sayısından azsa, Carmack'in korsanlığını kullanın, aksi takdirde açıklanan başka bir yöntem kullanın burada cevaplar.

Bu, bu iş parçacığında başkaları tarafından önerilen tekniklerin bir kombinasyonunu kullanarak, bulabildiğim en hızlı Java uygulamasıdır.

• Mod-256 testi
• Hatalı mod-3465 testi (bazı yanlış pozitiflerin maliyetinde tamsayı bölünmesini önler)
• Kayan noktalı karekök, yuvarlak ve girdi değeri ile karşılaştır

Ayrıca bu değişiklikleri denedim ancak performansa yardımcı olmadı:

• Ek mod-255 testi
• Giriş değerinin 4'lü güçlere bölünmesi
• Hızlı Ters Kare Kök (yüksek N değerleri için çalışmak için, donanım kare kök işlevinden daha yavaş hale getirmek için yeterli olan 3 yinelemeye ihtiyaç duyar.)

public class SquareTester {

    public static boolean isPerfectSquare(long n) {
        if (n < 0) {
            return false;
        } else {
            switch ((byte) n) {
            case -128: case -127: case -124: case -119: case -112:
            case -111: case -103: case  -95: case  -92: case  -87:
            case  -79: case  -71: case  -64: case  -63: case  -60:
            case  -55: case  -47: case  -39: case  -31: case  -28:
            case  -23: case  -15: case   -7: case    0: case    1:
            case    4: case    9: case   16: case   17: case   25:
            case   33: case   36: case   41: case   49: case   57:
            case   64: case   65: case   68: case   73: case   81:
            case   89: case   97: case  100: case  105: case  113:
            case  121:
                long i = (n * INV3465) >>> 52;
                if (! good3465[(int) i]) {
                    return false;
                } else {
                    long r = round(Math.sqrt(n));
                    return r*r == n; 
                }
            default:
                return false;
            }
        }
    }

    private static int round(double x) {
        return (int) Double.doubleToRawLongBits(x + (double) (1L << 52));
    }

    /** 3465<sup>-1</sup> modulo 2<sup>64</sup> */
    private static final long INV3465 = 0x8ffed161732e78b9L;

    private static final boolean[] good3465 =
        new boolean[0x1000];

    static {
        for (int r = 0; r < 3465; ++ r) {
            int i = (int) ((r * r * INV3465) >>> 52);
            good3465[i] = good3465[i+1] = true;
        }
    }

}