Je cherche le moyen le plus rapide pour déterminer si une longvaleur est un carré parfait (c'est-à-dire que sa racine carrée est un autre entier):

1. Je l'ai fait de manière simple, en utilisant la Math.sqrt() fonction intégrée, mais je me demande s'il y a un moyen de le faire plus rapidement en vous limitant au domaine entier.
2. Il n'est pas pratique de gérer une table de correspondance (car il existe environ 2 ^31,5 entiers dont le carré est inférieur à 2 ⁶³ ).

Voici la façon très simple et directe dont je le fais maintenant:

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

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

_{Remarque: J'utilise cette fonction dans de nombreux problèmes liés à Project Euler . Donc, personne d'autre n'aura jamais à maintenir ce code. Et ce type de micro-optimisation pourrait réellement faire une différence, car une partie du défi consiste à faire chaque algorithme en moins d'une minute, et cette fonction devra être appelée des millions de fois dans certains problèmes.}

J'ai essayé les différentes solutions au problème:

• Après des tests exhaustifs, j'ai trouvé que l'ajout 0.5au résultat de Math.sqrt () n'est pas nécessaire, du moins pas sur ma machine.
• La racine carrée inverse rapide était plus rapide, mais elle a donné des résultats incorrects pour n> = 410881. Cependant, comme suggéré par BobbyShaftoe , nous pouvons utiliser le hack FISR pour n <410881.
• La méthode de Newton était un peu plus lente que Math.sqrt(). C'est probablement parce qu'il Math.sqrt()utilise quelque chose de similaire à la méthode de Newton, mais implémenté dans le matériel, c'est donc beaucoup plus rapide qu'en Java. De plus, la méthode de Newton exigeait toujours l'utilisation de doubles.
• Une méthode de Newton modifiée, qui utilisait quelques astuces pour que seules les mathématiques entières soient impliquées, nécessitait des hacks pour éviter le débordement (je veux que cette fonction fonctionne avec tous les entiers signés 64 bits positifs), et elle était toujours plus lente que Math.sqrt().
• La coupe binaire était encore plus lente. Cela a du sens, car le découpage binaire nécessitera en moyenne 16 passes pour trouver la racine carrée d'un nombre 64 bits.
• Selon les tests de John, l'utilisation d' orinstructions est plus rapide en C ++ que l'utilisation de a switch, mais en Java et C #, il ne semble pas y avoir de différence entre oret switch.
• J'ai également essayé de créer une table de recherche (en tant que tableau statique privé de 64 valeurs booléennes). Ensuite, au lieu d'un commutateur ou d'une ordéclaration, je dirais simplement if(lookup[(int)(n&0x3F)]) { test } else return false;. À ma grande surprise, c'était (légèrement) plus lent. En effet , les limites des tableaux sont vérifiées en Java .

J'ai trouvé une méthode qui fonctionne ~ 35% plus rapidement que votre code 6bits + Carmack + sqrt, au moins avec mon CPU (x86) et mon langage de programmation (C / C ++). Vos résultats peuvent varier, surtout parce que je ne sais pas comment le facteur Java se déroulera.

Mon approche est triple:

1. Tout d'abord, filtrez les réponses évidentes. Cela inclut les nombres négatifs et en regardant les 4 derniers bits. (J'ai trouvé que regarder les six derniers n'a pas aidé.) Je réponds également oui à 0. (En lisant le code ci-dessous, notez que ma saisie est int64 x.)

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

2. Ensuite, vérifiez si c'est un carré modulo 255 = 3 * 5 * 17. Parce que c'est un produit de trois nombres premiers distincts, seulement environ 1/8 des résidus mod 255 sont des carrés. Cependant, d'après mon expérience, appeler l'opérateur modulo (%) coûte plus cher que l'avantage que l'on obtient, donc j'utilise des trucs de bits impliquant 255 = 2 ^ 8-1 pour calculer le résidu. (Pour le meilleur ou pour le pire, je n'utilise pas l'astuce de lecture des octets individuels d'un mot, seulement au niveau du bit et et des décalages.)

   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.

   Pour vérifier réellement si le résidu est un carré, je recherche la réponse dans un tableau précalculé.

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

3. Enfin, essayez de calculer la racine carrée en utilisant une méthode similaire au lemme de Hensel . (Je ne pense pas que cela s'applique directement, mais cela fonctionne avec quelques modifications.) Avant de faire cela, je divise tous les pouvoirs de 2 avec une recherche binaire:

   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;

   À ce stade, pour que notre nombre soit un carré, il doit être 1 mod 8.

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

   La structure de base du lemme de Hensel est la suivante. (Remarque: code non testé; s'il ne fonctionne pas, essayez t = 2 ou 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.

   L'idée est qu'à chaque itération, vous ajoutez un bit sur r, la racine carrée "courante" de x; chaque racine carrée est précise modulo une puissance de plus en plus grande de 2, à savoir t / 2. À la fin, r et t / 2-r seront des racines carrées de x modulo t / 2. (Notez que si r est une racine carrée de x, il en est de même pour -r. C'est vrai même les nombres modulo, mais attention, modulo certains nombres, les choses peuvent avoir encore plus de 2 racines carrées; cela inclut notamment les puissances de 2. ) Parce que notre racine carrée réelle est inférieure à 2 ^ 32, à ce stade, nous pouvons réellement vérifier si r ou t / 2-r sont de vraies racines carrées. Dans mon code actuel, j'utilise la boucle modifiée suivante:

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

   L'accélération ici est obtenue de trois manières: valeur de départ précalculée (équivalant à ~ 10 itérations de la boucle), sortie plus précoce de la boucle et saut de certaines valeurs t. Pour la dernière partie, je regarde z = r - x * xet règle t pour être la plus grande puissance de 2 divisant z avec un petit truc. Cela me permet de sauter des valeurs t qui n'auraient pas affecté la valeur de r de toute façon. La valeur de départ précalculée dans mon cas sélectionne le "plus petit positif" racine modulo 8192.

Même si ce code ne fonctionne pas plus rapidement pour vous, j'espère que vous apprécierez certaines des idées qu'il contient. Le code complet et testé suit, y compris les tables précalculées.

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

Je suis assez en retard à la fête, mais j'espère apporter une meilleure réponse; plus court et (en supposant que mon indice de référence est correct) aussi beaucoup plus rapide .

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

Le premier test capture rapidement la plupart des non-carrés. Il utilise une table de 64 éléments emballée dans un long, donc il n'y a pas de coût d'accès au tableau (vérifications d'indirection et de limites). Pour un aléatoire uniforme long, il y a une probabilité de 81,25% de se terminer ici.

Le deuxième test capture tous les nombres ayant un nombre impair de deux dans leur factorisation. La méthode Long.numberOfTrailingZerosest très rapide car elle est convertie en JIT dans une seule instruction i86.

Après avoir supprimé les zéros de fin, le troisième test gère les nombres se terminant par 011, 101 ou 111 en binaire, qui ne sont pas des carrés parfaits. Il se soucie également des nombres négatifs et gère également 0.

Le test final revient à l' doublearithmétique. Comme la doublemantisse n'a que 53 bits, la conversion de longà doubleinclut l'arrondi pour les grandes valeurs. Néanmoins, le test est correct (sauf si la preuve est fausse).

La tentative d'intégration de l'idée du mod255 n'a pas réussi.

Vous devrez faire des analyses comparatives. Le meilleur algorithme dépendra de la distribution de vos entrées.

Votre algorithme peut être presque optimal, mais vous voudrez peut-être faire une vérification rapide pour exclure certaines possibilités avant d'appeler votre routine racine carrée. Par exemple, regardez le dernier chiffre de votre numéro en hexadécimal en faisant un "et". Les carrés parfaits ne peuvent se terminer qu'en 0, 1, 4 ou 9 en base 16, donc pour 75% de vos entrées (en supposant qu'elles sont uniformément réparties), vous pouvez éviter un appel à la racine carrée en échange d'un peu de twiddling très rapide.

Kip a testé le code suivant implémentant l'astuce hex. Lors du test des numéros 1 à 100 000 000, ce code a fonctionné deux fois plus vite que l'original.

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

Lorsque j'ai testé le code analogue en C ++, il s'est en fait déroulé plus lentement que l'original. Cependant, lorsque j'ai supprimé l'instruction switch, l'astuce hexadécimale rend le code deux fois plus rapide.

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

L'élimination de l'instruction switch a eu peu d'effet sur le code C #.

Je pensais aux moments horribles que j'ai passés dans le cours d'analyse numérique.

Et puis je me souviens, il y avait cette fonction qui tournait autour du net à partir du code source de 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;
}

Ce qui calcule essentiellement une racine carrée, en utilisant la fonction d'approximation de Newton (je ne peux pas me souvenir du nom exact).

Il devrait être utilisable et pourrait même être plus rapide, il s'agit d'un des jeux phénoménaux du logiciel d'identification!

Il est écrit en C ++ mais il ne devrait pas être trop difficile de réutiliser la même technique en Java une fois que vous avez l'idée:

Je l'ai trouvé à l'origine sur: http://www.codemaestro.com/reviews/9

La méthode de Newton expliquée sur wikipedia: http://en.wikipedia.org/wiki/Newton%27s_method

Vous pouvez suivre le lien pour plus d'explications sur la façon dont cela fonctionne, mais si vous ne vous souciez pas beaucoup, c'est à peu près ce dont je me souviens en lisant le blog et en suivant le cours d'analyse numérique:

• il * (long*) &ys'agit essentiellement d'une fonction de conversion rapide en fonction longue de sorte que des opérations entières peuvent être appliquées sur les octets bruts.
• la 0x5f3759df - (i >> 1);ligne est une valeur de départ pré-calculée pour la fonction d'approximation.
• le * (float*) &iconvertit la valeur en virgule flottante.
• la y = y * ( threehalfs - ( x2 * y * y ) )ligne réitère basiquement la valeur sur la fonction.

La fonction d'approximation donne des valeurs plus précises plus vous itérez la fonction sur le résultat. Dans le cas de Quake, une itération est "assez bonne", mais si ce n'était pas pour vous ... alors vous pouvez ajouter autant d'itérations que vous le souhaitez.

Cela devrait être plus rapide car il réduit le nombre d'opérations de division effectuées en racine carrée naïve à une simple division par 2 (en fait une * 0.5Fopération de multiplication) et le remplace par un nombre fixe d'opérations de multiplication à la place.

Je ne sais pas si ce serait plus rapide, voire précis, mais vous pouvez utiliser l' algorithme Magical Square Root de John Carmack pour résoudre la racine carrée plus rapidement. Vous pourriez probablement facilement tester cela pour tous les entiers 32 bits possibles et valider que vous avez réellement obtenu des résultats corrects, car ce n'est qu'une appoximation. Cependant, maintenant que j'y pense, l'utilisation de doubles est également approximative, donc je ne sais pas comment cela pourrait entrer en jeu.

Si vous effectuez un découpage binaire pour essayer de trouver la "bonne" racine carrée, vous pouvez assez facilement détecter si la valeur que vous avez est suffisamment proche pour le dire:

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

Donc, après avoir calculé n^2, les options sont:

• n^2 = target: terminé, retourne vrai
• n^2 + 2n + 1 > target > n^2 : vous êtes proche, mais ce n'est pas parfait: retour faux
• n^2 - 2n + 1 < target < n^2 : idem
• target < n^2 - 2n + 1 : coupure binaire sur un fond n
• target > n^2 + 2n + 1 : coupure binaire sur un supérieur n

(Désolé, cela utilise n comme estimation actuelle et targetpour le paramètre. Veuillez vous excuser pour la confusion!)

Je ne sais pas si ce sera plus rapide ou non, mais ça vaut le coup d'essayer.

EDIT: Le cliché binaire n'a pas non plus à prendre toute la gamme d'entiers, (2^x)^2 = 2^(2x)donc une fois que vous avez trouvé le bit le plus haut dans votre cible (ce qui peut être fait avec une astuce de bit-twiddling; j'oublie exactement comment) vous pouvez rapidement obtenir une gamme de réponses potentielles. Attention, une côtelette binaire naïve ne prendra toujours que 31 ou 32 itérations.

J'ai exécuté ma propre analyse de plusieurs des algorithmes de ce fil et j'ai trouvé de nouveaux résultats. Vous pouvez voir ces anciens résultats dans l'historique des modifications de cette réponse, mais ils ne sont pas précis, car j'ai fait une erreur et perdu du temps à analyser plusieurs algorithmes qui ne sont pas proches. Cependant, tirant des leçons de plusieurs réponses différentes, j'ai maintenant deux algorithmes qui écrasent le "gagnant" de ce fil. Voici l'essentiel que je fais différemment de tout le monde:

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

Cependant, cette ligne simple, qui ajoute la plupart du temps une ou deux instructions très rapides, simplifie considérablement l' switch-caseinstruction en une instruction if. Cependant, il peut s'ajouter à l'exécution si de nombreux nombres testés ont des facteurs de puissance de deux significatifs.

Les algorithmes ci-dessous sont les suivants:

• Internet - La réponse publiée de Kip
• Durron - Ma réponse modifiée utilisant la réponse en un seul passage comme base
• DurronTwo - Ma réponse modifiée utilisant la réponse en deux passes (par @JohnnyHeggheim), avec quelques autres légères modifications.

Voici un exemple d'exécution si les nombres sont générés à l'aide 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

Et voici un exemple d'exécution s'il est exécuté uniquement sur le premier million de longs:

 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

Comme vous pouvez le voir, DurronTwofait mieux pour les grandes entrées, car il utilise très souvent le tour de magie, mais est encombré par rapport au premier algorithme et Math.sqrtparce que les nombres sont tellement plus petits. Pendant ce temps, le plus simpleDurron est un énorme gagnant car il n'a jamais à diviser par 4 plusieurs fois dans le premier million de nombres.

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

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

Et mon harnais de référence: (Nécessite un étrier Google 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);
    }
}

MISE À JOUR: J'ai créé un nouvel algorithme qui est plus rapide dans certains scénarios, plus lent dans d'autres, j'ai obtenu différents repères basés sur différentes entrées. Si nous calculons le modulo 0xFFFFFF = 3 x 3 x 5 x 7 x 13 x 17 x 241, nous pouvons éliminer 97,82% des nombres qui ne peuvent pas être des carrés. Cela peut être (en quelque sorte) effectué sur une seule ligne, avec 5 opérations au niveau du bit:

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

L'indice résultant est soit 1) le résidu, 2) le résidu + 0xFFFFFF, ou 3) le résidu + 0x1FFFFFE. Bien sûr, nous devons avoir une table de recherche pour les résidus modulo 0xFFFFFF, qui représente environ un fichier de 3 Mo (dans ce cas, stocké sous forme de nombres décimaux de texte ascii, pas optimal mais clairement améliorable avec a ByteBufferet ainsi de suite. C'est si important. Vous pouvez trouver le fichier ici (ou le générer vous-même):

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

Je le charge dans un booleantableau comme celui-ci:

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

Exemple d'exécution. Il a battu Durron(version un) dans chaque essai que j'ai couru.

 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

Il devrait être beaucoup plus rapide d'utiliser la méthode de Newton pour calculer la racine carrée entière , puis de mettre ce nombre au carré et de vérifier, comme vous le faites dans votre solution actuelle. La méthode de Newton est la base de la solution de Carmack mentionnée dans certaines autres réponses. Vous devriez pouvoir obtenir une réponse plus rapide, car vous n'êtes intéressé que par la partie entière de la racine, ce qui vous permet d'arrêter l'algorithme d'approximation plus tôt.

Une autre optimisation que vous pouvez essayer: si la racine numérique d'un nombre ne se termine pas par 1, 4, 7 ou 9, le nombre n'est pas un carré parfait. Cela peut être utilisé comme un moyen rapide d'éliminer 60% de vos entrées avant d'appliquer l'algorithme de racine carrée plus lent.

Je veux que cette fonction fonctionne avec tous les entiers signés 64 bits positifs

Math.sqrt()fonctionne avec des doubles comme paramètres d'entrée, donc vous n'obtiendrez pas de résultats précis pour des entiers supérieurs à 2 ^ 53 .

Pour mémoire, une autre approche consiste à utiliser la décomposition principale. Si chaque facteur de la décomposition est pair, alors le nombre est un carré parfait. Donc, ce que vous voulez, c'est voir si un nombre peut être décomposé comme un produit de carrés de nombres premiers. Bien sûr, vous n'avez pas besoin d'obtenir une telle décomposition, juste pour voir si elle existe.

Construisez d'abord un tableau de carrés de nombres premiers inférieurs à 2 ^ 32. C'est beaucoup plus petit qu'une table de tous les nombres entiers jusqu'à cette limite.

Une solution serait alors comme ceci:

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

Je suppose que c'est un peu cryptique. Il vérifie à chaque étape que le carré d'un nombre premier divise le nombre entré. Si c'est le cas, il divise le nombre par le carré aussi longtemps que possible, pour retirer ce carré de la décomposition principale. Si par ce processus, nous arrivions à 1, alors le nombre d'entrée était une décomposition du carré des nombres premiers. Si le carré devient plus grand que le nombre lui-même, il n'y a aucun moyen que ce carré, ou des carrés plus grands, puisse le diviser, donc le nombre ne peut pas être une décomposition de carrés de nombres premiers.

Étant donné le sqrt de nos jours fait en matériel et la nécessité de calculer des nombres premiers ici, je suppose que cette solution est beaucoup plus lente. Mais cela devrait donner de meilleurs résultats que la solution avec sqrt qui ne fonctionnera pas sur 2 ^ 54, comme le dit mrzl dans sa réponse.

Il a été souligné que les derniers dchiffres d'un carré parfait ne peuvent prendre que certaines valeurs. Les derniers dchiffres (en base b) d'un nombre nsont les mêmes que le reste lorsqu'il nest divisé par bd, c'est-à-dire. en notation C n % pow(b, d).

Cela peut être généralisé à n'importe quel module m, c'est-à-dire. n % mpeut être utilisé pour exclure un certain pourcentage des nombres d'être des carrés parfaits. Le module que vous utilisez actuellement est de 64, ce qui permet 12, c'est-à-dire. 19% des restes, comme des carrés possibles. Avec un peu de codage j'ai trouvé le module 110880, qui ne permet que 2016, c'est à dire. 1,8% des restes comme carrés possibles. Ainsi, en fonction du coût d'une opération de module (c.-à-d. Division) et d'une recherche de table par rapport à une racine carrée sur votre machine, l'utilisation de ce module peut être plus rapide.

Soit dit en passant, si Java a un moyen de stocker un tableau compact de bits pour la table de recherche, ne l'utilisez pas. 110880 Les mots 32 bits ne consomment pas beaucoup de RAM de nos jours et la récupération d'un mot machine va être plus rapide que la récupération d'un seul bit.

Un problème entier mérite une solution entière. Donc

Effectuez une recherche binaire sur les entiers (non négatifs) pour trouver le plus grand entier t tel que t**2 <= n. Testez ensuite si r**2 = nexactement. Cela prend du temps O (log n).

Si vous ne savez pas comment rechercher binaire les entiers positifs parce que l'ensemble est illimité, c'est facile. Vous commencez par calculer votre fonction croissante f (ci-dessus f(t) = t**2 - n) sur des puissances de deux. Lorsque vous le voyez devenir positif, vous avez trouvé une limite supérieure. Ensuite, vous pouvez faire une recherche binaire standard.

La simplification suivante de la solution de maaartinus semble réduire de quelques points le temps d'exécution, mais je ne suis pas assez bon en analyse comparative pour produire une référence en laquelle je peux avoir confiance:

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

Il vaudrait la peine de vérifier comment omettre le premier test,

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

affecterait les performances.

Pour les performances, vous devez très souvent faire quelques compromis. D'autres ont exprimé diverses méthodes, cependant, vous avez noté que le piratage de Carmack était plus rapide jusqu'à certaines valeurs de N. Ensuite, vous devriez vérifier le "n" et s'il est inférieur à ce nombre N, utilisez le piratage de Carmack, sinon utilisez une autre méthode décrite dans les réponses ici.

C'est l'implémentation Java la plus rapide que j'ai pu trouver, en utilisant une combinaison de techniques suggérées par d'autres dans ce fil.

• Test Mod-256
• Test mod-3465 inexact (évite la division entière au prix de certains faux positifs)
• Racine carrée à virgule flottante, arrondir et comparer avec la valeur d'entrée

J'ai également expérimenté ces modifications mais elles n'ont pas amélioré les performances:

• Test mod-255 supplémentaire
• Diviser la valeur d'entrée par des puissances de 4
• Racine carrée inverse rapide (pour travailler pour des valeurs élevées de N, il faut 3 itérations, assez pour la rendre plus lente que la fonction racine carrée matérielle.)

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

}