Saya mencari cara tercepat untuk menentukan apakah suatu longnilai adalah kuadrat sempurna (yaitu akar kuadratnya adalah bilangan bulat lain):

1. Saya telah melakukannya dengan cara mudah, dengan menggunakan Math.sqrt() fungsi bawaan, tetapi saya bertanya-tanya apakah ada cara untuk melakukannya lebih cepat dengan membatasi diri Anda ke domain integer-only.
2. Mempertahankan tabel pencarian tidak praktis (karena ada sekitar 2 ^31,5 bilangan bulat yang kuadratnya kurang dari 2 ⁶³ ).

Inilah cara yang sangat sederhana dan mudah yang saya lakukan sekarang:

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

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

_{Catatan: Saya menggunakan fungsi ini di banyak masalah Project Euler . Jadi tidak ada orang lain yang harus mempertahankan kode ini. Dan optimasi mikro semacam ini sebenarnya bisa membuat perbedaan, karena bagian dari tantangannya adalah melakukan setiap algoritma dalam waktu kurang dari satu menit, dan fungsi ini perlu disebut jutaan kali dalam beberapa masalah.}

Saya sudah mencoba berbagai solusi untuk masalah ini:

• Setelah pengujian menyeluruh, saya menemukan bahwa menambahkan 0.5ke hasil Math.sqrt () tidak diperlukan, setidaknya tidak pada mesin saya.
• The cepat terbalik akar kuadrat lebih cepat, tapi itu memberi hasil yang salah untuk n> = 410881. Namun, seperti yang disarankan oleh BobbyShaftoe , kita dapat menggunakan hack FISR untuk n <410.881.
• Metode Newton sedikit lebih baik daripada Math.sqrt(). Ini mungkin karena Math.sqrt()menggunakan sesuatu yang mirip dengan Metode Newton, tetapi diterapkan pada perangkat keras sehingga jauh lebih cepat daripada di Jawa. Juga, Metode Newton masih membutuhkan penggunaan ganda.
• Metode Newton yang dimodifikasi, yang menggunakan beberapa trik sehingga hanya matematika bilangan bulat yang terlibat, diperlukan beberapa peretasan untuk menghindari overflow (Saya ingin fungsi ini bekerja dengan semua bilangan bulat bertanda positif 64-bit), dan masih lebih lambat daripada Math.sqrt().
• Chop biner bahkan lebih lambat. Ini masuk akal karena memotong biner rata-rata akan memerlukan 16 lintasan untuk menemukan akar kuadrat dari angka 64-bit.
• Menurut tes John, menggunakan orpernyataan lebih cepat di C ++ daripada menggunakan a switch, tetapi di Jawa dan C # tampaknya tidak ada perbedaan antara ordan switch.
• Saya juga mencoba membuat tabel pencarian (sebagai array statis privat dari nilai 64 boolean). Maka alih-alih beralih atau orpernyataan, saya hanya akan mengatakan if(lookup[(int)(n&0x3F)]) { test } else return false;. Yang mengejutkan saya, ini (hanya sedikit) lebih lambat. Ini karena batas array diperiksa di Jawa .

Saya menemukan metode yang bekerja ~ 35% lebih cepat dari kode 6bit + Carmack + sqrt Anda, setidaknya dengan CPU saya (x86) dan bahasa pemrograman (C / C ++). Hasil Anda dapat bervariasi, terutama karena saya tidak tahu bagaimana faktor Java akan dimainkan.

Pendekatan saya ada tiga:

1. Pertama, filter jawaban yang jelas. Ini termasuk angka negatif dan melihat 4 bit terakhir. (Saya menemukan melihat enam yang terakhir tidak membantu.) Saya juga menjawab ya untuk 0. (Dalam membaca kode di bawah ini, perhatikan bahwa input saya adalah int64 x.)

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

2. Selanjutnya, periksa apakah itu adalah modulo 255 = 3 * 5 * 17. Karena itu adalah produk dari tiga bilangan prima yang berbeda, hanya sekitar 1/8 residu mod 255 yang berbentuk bujur sangkar. Namun, dalam pengalaman saya, memanggil operator modulo (%) lebih mahal daripada manfaatnya, jadi saya menggunakan sedikit trik yang melibatkan 255 = 2 ^ 8-1 untuk menghitung residu. (Untuk lebih baik atau lebih buruk, saya tidak menggunakan trik membaca byte individu dari sebuah kata, hanya bitwise-and dan bergeser.)

   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.
   

   Untuk benar-benar memeriksa apakah residu adalah kuadrat, saya mencari jawabannya di tabel yang sudah dihitung sebelumnya.

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

3. Akhirnya, cobalah untuk menghitung akar kuadrat menggunakan metode yang mirip dengan lemma Hensel . (Saya tidak berpikir itu berlaku secara langsung, tetapi bekerja dengan beberapa modifikasi.) Sebelum melakukan itu, saya membagi semua kekuatan 2 dengan pencarian biner:

   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;

   Pada titik ini, agar angka kita menjadi bujur sangkar, itu harus 1 mod 8.

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

   Struktur dasar lemens Hensel adalah sebagai berikut. (Catatan: kode yang belum diuji; jika tidak berhasil, coba t = 2 atau 8.)

   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.

   Idenya adalah bahwa pada setiap iterasi, Anda menambahkan satu bit ke r, akar kuadrat "saat ini" dari x; setiap root kuadrat adalah modulo akurat yang lebih besar dan lebih besar dari 2 daya, yaitu t / 2 Pada akhirnya, r dan t / 2-r akan menjadi akar kuadrat dari x modulo t / 2. (Perhatikan bahwa jika r adalah akar kuadrat dari x, maka demikian juga -r. Ini benar bahkan nomor modulo, tetapi berhati-hatilah, modulo beberapa angka, hal-hal dapat memiliki lebih dari 2 akar kuadrat; terutama, ini termasuk kekuatan 2. ) Karena akar kuadrat aktual kita kurang dari 2 ^ 32, pada titik itu kita dapat benar-benar memeriksa apakah r atau t / 2-r adalah akar kuadrat nyata. Dalam kode saya yang sebenarnya, saya menggunakan loop yang dimodifikasi berikut:

   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) );

   Speedup di sini diperoleh dalam tiga cara: nilai awal yang dikomputasi (setara dengan ~ 10 iterasi loop), keluar sebelumnya dari loop, dan melewatkan beberapa nilai t. Untuk bagian terakhir, saya melihat z = r - x * x, dan mengatur t menjadi kekuatan terbesar dari 2 z membagi dengan sedikit trik. Ini memungkinkan saya untuk melewatkan nilai t yang tidak akan memengaruhi nilai r. Nilai awal yang dikomputasi dalam kasus saya memilih modulo 8192 akar kuadrat "positif terkecil".

Bahkan jika kode ini tidak bekerja lebih cepat untuk Anda, saya harap Anda menikmati beberapa ide yang terkandung di dalamnya. Kode lengkap dan teruji mengikuti, termasuk tabel prakomputasi.

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;
}

Saya sangat terlambat ke pesta, tetapi saya berharap dapat memberikan jawaban yang lebih baik; lebih pendek dan (dengan asumsi tolok ukur saya benar) juga jauh lebih cepat .

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;
}

Tes pertama menangkap sebagian besar non-kotak dengan cepat. Ini menggunakan tabel 64-item yang dikemas dalam panjang, jadi tidak ada biaya akses array (tipuan dan cek batas). Untuk acak yang seragam long, ada kemungkinan 81,25% untuk berakhir di sini.

Tes kedua menangkap semua angka yang memiliki jumlah ganjil dari dua faktorisasi mereka. Metode Long.numberOfTrailingZerosini sangat cepat karena mendapat JIT-ed menjadi instruksi i86 tunggal.

Setelah menjatuhkan nol yang tertinggal, tes ketiga menangani angka yang berakhiran 011, 101, atau 111 dalam biner, yang bukan kotak yang sempurna. Ini juga peduli tentang angka negatif dan juga menangani 0.

Tes akhir jatuh kembali ke doublearitmatika. Karena doublehanya memiliki 53 bit mantissa, konversi dari longmenjadi doublepembulatan untuk nilai besar. Meskipun demikian, tes ini benar (kecuali buktinya salah).

Mencoba memasukkan ide mod255 tidak berhasil.

Anda harus melakukan pembandingan. Algoritma terbaik akan tergantung pada distribusi input Anda.

Algoritme Anda mungkin hampir optimal, tetapi Anda mungkin ingin melakukan pemeriksaan cepat untuk mengesampingkan beberapa kemungkinan sebelum memanggil rutin akar kuadrat Anda. Sebagai contoh, lihat digit terakhir nomor Anda dalam hex dengan melakukan sedikit-bijaksana "dan." Kuadrat sempurna hanya bisa berakhir pada 0, 1, 4, atau 9 di basis 16, Jadi untuk 75% dari input Anda (dengan asumsi mereka terdistribusi secara merata) Anda dapat menghindari panggilan ke root kuadrat dengan imbalan sedikit twiddling yang sangat cepat.

Kip membandingkan kode berikut ini dengan mengimplementasikan trik heks. Saat menguji angka 1 hingga 100.000.000, kode ini berlari dua kali lebih cepat dari aslinya.

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;
    }
}

Ketika saya menguji kode analog dalam C ++, itu sebenarnya berjalan lebih lambat dari aslinya. Namun, ketika saya menghilangkan pernyataan switch, trik hex sekali lagi membuat kode dua kali lebih cepat.

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;
}

Menghilangkan pernyataan switch tidak banyak berpengaruh pada kode C #.

Saya berpikir tentang saat-saat mengerikan yang saya habiskan dalam kursus Analisis Numerik.

Dan kemudian saya ingat, ada fungsi ini berputar-putar di sekitar 'net dari kode Sumber Quake:

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;
}

Yang pada dasarnya menghitung akar kuadrat, menggunakan fungsi perkiraan Newton (tidak ingat nama persisnya).

Itu harus dapat digunakan dan bahkan mungkin lebih cepat, itu dari salah satu permainan perangkat lunak id fenomenal!

Ini ditulis dalam C ++ tetapi seharusnya tidak terlalu sulit untuk menggunakan kembali teknik yang sama di Jawa setelah Anda mendapatkan ide:

Saya awalnya menemukannya di: http://www.codemaestro.com/reviews/9

Metode Newton dijelaskan di wikipedia: http://en.wikipedia.org/wiki/Newton%27s_method

Anda dapat mengikuti tautan untuk penjelasan lebih lanjut tentang cara kerjanya, tetapi jika Anda tidak terlalu peduli, maka inilah kira-kira yang saya ingat dari membaca blog dan dari mengambil kursus Analisis Numerik:

• pada * (long*) &ydasarnya adalah fungsi convert-to-long yang cepat sehingga operasi integer dapat diterapkan pada byte mentah.
• yang 0x5f3759df - (i >> 1);garis adalah nilai benih pra-dihitung untuk fungsi pendekatan.
• yang * (float*) &imengubah nilai kembali ke floating point.
• yang y = y * ( threehalfs - ( x2 * y * y ) )garis bascially iterates nilai alih fungsi lagi.

Fungsi aproksimasi memberikan nilai yang lebih tepat semakin banyak Anda mengulangi fungsi dibandingkan hasilnya. Dalam kasus Quake, satu iterasi adalah "cukup baik", tetapi jika itu bukan untuk Anda ... maka Anda dapat menambahkan sebanyak iterasi yang Anda butuhkan.

Ini harus lebih cepat karena mengurangi jumlah operasi divisi yang dilakukan dalam rooting naif menjadi pembagian sederhana dengan 2 (sebenarnya * 0.5Foperasi multiply) dan menggantinya dengan beberapa operasi multiplikasi sebagai gantinya.

Saya tidak yakin apakah itu akan lebih cepat, atau bahkan akurat, tetapi Anda dapat menggunakan algoritma Magical Square Root dari John Carmack , untuk memecahkan akar kuadrat lebih cepat. Anda mungkin dapat dengan mudah menguji ini untuk semua kemungkinan integer 32 bit, dan memvalidasi bahwa Anda benar-benar mendapatkan hasil yang benar, karena itu hanya appoximation. Namun, sekarang saya berpikir tentang hal itu, menggunakan ganda hampir sama, jadi saya tidak yakin bagaimana itu akan ikut bermain.

Jika Anda melakukan pemotongan biner untuk mencoba menemukan akar kuadrat "benar", Anda dapat dengan mudah mendeteksi jika nilai yang Anda miliki cukup dekat untuk mengatakan:

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

Jadi setelah dihitung n^2, opsinya adalah:

• n^2 = target: selesai, kembali benar
• n^2 + 2n + 1 > target > n^2 : Anda dekat, tetapi itu tidak sempurna: return false
• n^2 - 2n + 1 < target < n^2 : ditto
• target < n^2 - 2n + 1 : memotong biner di bagian bawah n
• target > n^2 + 2n + 1 : memotong biner pada yang lebih tinggi n

(Maaf, ini digunakan nsebagai tebakan Anda saat ini, dan targetuntuk parameter. Mohon maaf atas kebingungan!)

Saya tidak tahu apakah ini akan lebih cepat atau tidak, tetapi patut dicoba.

EDIT: Chop biner tidak harus mengambil seluruh jajaran bilangan bulat, (2^x)^2 = 2^(2x)jadi, begitu Anda telah menemukan bit set teratas di target Anda (yang dapat dilakukan dengan trik sedikit-twiddling; saya lupa persis bagaimana) Anda dapat dengan cepat mendapatkan berbagai jawaban potensial. Pikiran Anda, memotong biner naif masih hanya akan memakan waktu hingga 31 atau 32 iterasi.

Saya menjalankan analisis saya sendiri dari beberapa algoritma di utas ini dan menghasilkan beberapa hasil baru. Anda dapat melihat hasil lama dalam riwayat edit jawaban ini, tetapi hasilnya tidak akurat, karena saya membuat kesalahan, dan membuang-buang waktu menganalisis beberapa algoritma yang tidak dekat. Namun, menarik pelajaran dari beberapa jawaban yang berbeda, saya sekarang memiliki dua algoritma yang menghancurkan "pemenang" utas ini. Inilah hal inti yang saya lakukan berbeda dari orang lain:

// 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;

Namun, baris sederhana ini, yang sebagian besar waktu menambahkan satu atau dua instruksi yang sangat cepat, sangat menyederhanakan switch-casepernyataan menjadi satu jika pernyataan. Namun, ini dapat menambah runtime jika banyak angka yang diuji memiliki kekuatan dua faktor yang signifikan.

Algoritma di bawah ini adalah sebagai berikut:

• Internet - Jawaban yang diposting Kip
• Durron - Jawaban saya yang dimodifikasi menggunakan jawaban satu langkah sebagai dasar
• DurronTwo - Jawaban saya yang dimodifikasi menggunakan jawaban dua-pass (oleh @JohnnyHeggheim), dengan beberapa modifikasi kecil lainnya.

Berikut ini adalah contoh runtime jika angka-angka tersebut dihasilkan menggunakan 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

Dan berikut ini contoh runtime jika dijalankan hanya pada satu juta long pertama:

 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

Seperti yang Anda lihat, DurronTwomelakukan lebih baik untuk input besar, karena bisa menggunakan trik sulap sangat sering, tetapi akan musnah dibandingkan dengan algoritma pertama dan Math.sqrtkarena jumlahnya jauh lebih kecil. Sementara itu, yang lebih simpel Durronadalah pemenang yang sangat besar karena tidak pernah harus membelah sebanyak 4 kali lipat dalam jutaan angka pertama.

Inilah 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;
}

Dan 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;
}

Dan harness benchmark saya: (Membutuhkan Google caliper 0.1-rc5)

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);
    }
}

UPDATE: Saya telah membuat algoritma baru yang lebih cepat dalam beberapa skenario, lebih lambat dalam skenario lain, saya mendapatkan tolok ukur yang berbeda berdasarkan input yang berbeda. Jika kita menghitung modulo 0xFFFFFF = 3 x 3 x 5 x 7 x 13 x 17 x 241, kita bisa menghilangkan 97,82% dari angka yang tidak bisa kuadrat. Ini dapat (semacam) dilakukan dalam satu baris, dengan 5 operasi bitwise:

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

Indeks yang dihasilkan adalah 1) residu, 2) residu + 0xFFFFFF, atau 3) residu + 0x1FFFFFE. Tentu saja, kita perlu memiliki tabel pencarian untuk residu modulo 0xFFFFFF, yaitu sekitar 3mb file (dalam hal ini disimpan sebagai angka desimal teks ascii, tidak optimal tetapi jelas tidak dapat diperbaiki dengan a ByteBufferdan sebagainya. Tapi karena itu perhitungan awal tidak jadi ' sangat penting. Anda dapat menemukan file di sini (atau menghasilkan sendiri):

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;
}

Saya memuatnya ke dalam booleanarray seperti ini:

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();
}

Contoh runtime. Itu mengalahkan Durron(versi satu) di setiap percobaan saya berlari.

 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

Seharusnya lebih cepat menggunakan metode Newton untuk menghitung Integer Square Root , lalu kuadratkan angka ini dan periksa, seperti yang Anda lakukan dalam solusi Anda saat ini. Metode Newton adalah dasar untuk solusi Carmack yang disebutkan dalam beberapa jawaban lain. Anda harus bisa mendapatkan jawaban yang lebih cepat karena Anda hanya tertarik pada bagian integer dari root, memungkinkan Anda untuk menghentikan algoritma aproksimasi lebih awal.

Pengoptimalan lain yang dapat Anda coba: Jika Digital Root suatu angka tidak berakhir pada 1, 4, 7, atau 9 angka itu bukan kuadrat sempurna. Ini dapat digunakan sebagai cara cepat untuk menghilangkan 60% dari input Anda sebelum menerapkan algoritma root square yang lebih lambat.

Saya ingin fungsi ini bekerja dengan semua bilangan bulat bertanda positif 64-bit

Math.sqrt()bekerja dengan ganda sebagai parameter input, sehingga Anda tidak akan mendapatkan hasil yang akurat untuk bilangan bulat lebih besar dari 2 ^ 53 .

Sebagai catatan, pendekatan lain adalah menggunakan dekomposisi utama. Jika setiap faktor dekomposisi genap, maka angkanya adalah kuadrat sempurna. Jadi yang Anda inginkan adalah melihat apakah suatu angka dapat diuraikan sebagai produk kuadrat bilangan prima. Tentu saja, Anda tidak perlu mendapatkan dekomposisi seperti itu, hanya untuk melihat apakah itu ada.

Pertama-tama buatlah sebuah kotak kuadrat dari bilangan prima yang lebih rendah dari 2 ^ 32. Ini jauh lebih kecil dari tabel semua bilangan bulat hingga batas ini.

Sebuah solusi akan menjadi seperti ini:

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;
    }
}

Saya kira itu agak samar. Apa yang dilakukannya adalah memeriksa di setiap langkah bahwa kuadrat dari bilangan prima membagi nomor input. Jika tidak maka itu membagi angka dengan kuadrat selama mungkin, untuk menghapus kuadrat ini dari dekomposisi utama. Jika dengan proses ini, kita sampai ke 1, maka nomor input adalah dekomposisi kuadrat dari bilangan prima. Jika kuadrat menjadi lebih besar dari angka itu sendiri, maka tidak mungkin kuadrat ini, atau kuadrat yang lebih besar, dapat membaginya, sehingga angka tersebut tidak dapat menjadi dekomposisi kuadrat dari bilangan prima.

Mengingat sqrt saat ini dilakukan dalam perangkat keras dan kebutuhan untuk menghitung bilangan prima di sini, saya kira solusi ini jauh lebih lambat. Tetapi harus memberikan hasil yang lebih baik daripada solusi dengan sqrt yang tidak akan bekerja lebih dari 2 ^ 54, seperti kata mrzl dalam jawabannya.

Telah ditunjukkan bahwa ddigit terakhir dari bujur sangkar sempurna hanya dapat mengambil nilai-nilai tertentu. dDigit terakhir (dalam basis b) dari angka nsama dengan sisa ketika ndibagi dengan bd, yaitu. dalam notasi C n % pow(b, d).

Ini dapat digeneralisasi ke modulus apa pun m, yaitu. n % mdapat digunakan untuk mengesampingkan beberapa persentase angka dari menjadi kuadrat sempurna. Modulus yang Anda gunakan saat ini adalah 64, yang memungkinkan 12, yaitu. 19% dari sisa, kotak mungkin. Dengan sedikit pengkodean saya menemukan modulus 110880, yang memungkinkan hanya 2016, yaitu. 1,8% dari sisa kotak mungkin. Jadi tergantung pada biaya operasi modulus (mis. Divisi) dan pencarian tabel versus akar kuadrat pada mesin Anda, menggunakan modulus ini mungkin lebih cepat.

Omong-omong jika Java memiliki cara untuk menyimpan array bit yang dikemas untuk tabel pencarian, jangan gunakan itu. 110880 kata 32-bit tidak banyak RAM hari ini dan mengambil kata mesin akan lebih cepat daripada mengambil sedikit pun.

Masalah bilangan bulat layak mendapatkan solusi bilangan bulat. Jadi

Lakukan pencarian biner pada bilangan bulat (non-negatif) untuk menemukan t bilangan bulat terbesar sehingga t**2 <= n. Kemudian uji apakah r**2 = ntepat. Ini membutuhkan waktu O (log n).

Jika Anda tidak tahu cara mencari biner bilangan bulat positif karena set tidak terikat, itu mudah. Anda mulai dengan menghitung fungsi Anda yang meningkat f (di atas f(t) = t**2 - n) dengan kekuatan dua. Ketika Anda melihatnya berubah positif, Anda telah menemukan batas atas. Kemudian Anda dapat melakukan pencarian biner standar.

Penyederhanaan solusi maaartinus berikut ini tampaknya mengurangi beberapa poin persentase dari runtime, tapi saya tidak cukup baik dalam membuat tolok ukur untuk menghasilkan tolok ukur yang dapat saya percayai:

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;
}

Akan bermanfaat untuk memeriksa bagaimana menghilangkan tes pertama,

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

akan mempengaruhi kinerja.

Untuk kinerja, Anda seringkali harus melakukan beberapa kompromi. Yang lain telah mengungkapkan berbagai metode, namun, Anda mencatat hack Carmack lebih cepat hingga nilai-nilai N. tertentu. Kemudian, Anda harus memeriksa "n" dan jika kurang dari angka N itu, gunakan hack Carmack, atau gunakan beberapa metode lain yang dijelaskan dalam jawaban di sini.

Ini adalah implementasi Java tercepat yang bisa saya buat, menggunakan kombinasi teknik yang disarankan oleh orang lain di utas ini.

• Tes Mod-256
• Tes mod-3465 tidak eksak (menghindari pembagian bilangan bulat dengan mengorbankan beberapa positif palsu)
• Akar kuadrat poin mengambang, bulat dan bandingkan dengan nilai input

Saya juga bereksperimen dengan modifikasi ini tetapi mereka tidak membantu kinerja:

• Tes mod-255 tambahan
• Membagi nilai input dengan kekuatan 4
• Fast Inverse Square Root (untuk mendapatkan nilai N yang tinggi diperlukan 3 iterasi, cukup untuk membuatnya lebih lambat daripada fungsi akar kuadrat perangkat keras.)

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;
        }
    }

}