Ich suche nach dem schnellsten Weg, um festzustellen, ob ein longWert ein perfektes Quadrat ist (dh seine Quadratwurzel ist eine andere ganze Zahl):

1. Ich habe es auf einfache Weise mit der integrierten Math.sqrt() Funktion gemacht, aber ich frage mich, ob es eine Möglichkeit gibt, es schneller zu machen, indem Sie sich auf eine Nur-Ganzzahl-Domäne beschränken.
2. Das Verwalten einer Nachschlagetabelle ist unpraktisch (da es ungefähr 2 ^31,5 Ganzzahlen gibt, deren Quadrat kleiner als 2 ^{63 ist} ).

Hier ist die sehr einfache und unkomplizierte Art, wie ich es jetzt mache:

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

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

_{Hinweis: Ich verwende diese Funktion bei vielen Project Euler- Problemen. Niemand sonst wird diesen Code jemals pflegen müssen. Und diese Art der Mikrooptimierung könnte tatsächlich einen Unterschied machen, da ein Teil der Herausforderung darin besteht, jeden Algorithmus in weniger als einer Minute auszuführen, und diese Funktion muss bei einigen Problemen millionenfach aufgerufen werden.}

Ich habe die verschiedenen Lösungen für das Problem ausprobiert:

• Nach ausführlichen Tests stellte ich fest, dass das Hinzufügen 0.5zum Ergebnis von Math.sqrt () nicht erforderlich ist, zumindest nicht auf meinem Computer.
• Die schnelle inverse Quadratwurzel war schneller, ergab jedoch falsche Ergebnisse für n> = 410881. Wie von BobbyShaftoe vorgeschlagen , können wir den FISR-Hack für n <410881 verwenden.
• Newtons Methode war ein bisschen langsamer als Math.sqrt() . Das liegt wahrscheinlich daranMath.sqrt() etwas Ähnliches wie Newtons Methode verwendet wird, jedoch in der Hardware implementiert ist, sodass es viel schneller als in Java ist. Außerdem erforderte die Newtonsche Methode immer noch die Verwendung von Doppel.
• Eine modifizierte Newton-Methode, bei der einige Tricks verwendet wurden, sodass nur ganzzahlige Mathematik beteiligt war, erforderte einige Hacks, um einen Überlauf zu vermeiden (ich möchte, dass diese Funktion mit allen positiven 64-Bit-Ganzzahlen mit Vorzeichen funktioniert), und sie war immer noch langsamer als Math.sqrt() .
• Binary Chop war noch langsamer. Dies ist sinnvoll, da der binäre Chop durchschnittlich 16 Durchgänge benötigt, um die Quadratwurzel einer 64-Bit-Zahl zu finden.
• Laut Johns Tests ist die Verwendung von orAnweisungen in C ++ schneller als die Verwendung von a switch, aber in Java und C # scheint es keinen Unterschied zwischen orund zu gebenswitch .
• Ich habe auch versucht, eine Nachschlagetabelle zu erstellen (als privates statisches Array mit 64 booleschen Werten). Dann orwürde ich statt Schalter oder Anweisung einfach sagen if(lookup[(int)(n&0x3F)]) { test } else return false;. Zu meiner Überraschung war dies (nur geringfügig) langsamer. Dies liegt daran, dass Array-Grenzen in Java überprüft werden .

Ich habe eine Methode gefunden, die ~ 35% schneller funktioniert als Ihr 6-Bit + Carmack + SQL-Code, zumindest mit meiner CPU (x86) und Programmiersprache (C / C ++). Ihre Ergebnisse können variieren, insbesondere weil ich nicht weiß, wie sich der Java-Faktor auswirken wird.

Mein Ansatz ist dreifach:

1. Filtern Sie zunächst offensichtliche Antworten heraus. Dies schließt negative Zahlen und das Betrachten der letzten 4 Bits ein. (Ich habe festgestellt, dass das Betrachten der letzten sechs nicht geholfen hat.) Ich antworte auch mit Ja für 0. (Beachten Sie beim Lesen des folgenden Codes, dass meine Eingabe lautet int64 x.)

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

2. Überprüfen Sie als nächstes, ob es sich um ein Quadrat Modulo 255 = 3 * 5 * 17 handelt. Da dies ein Produkt aus drei verschiedenen Primzahlen ist, sind nur etwa 1/8 der Reste Mod 255 Quadrate. Nach meiner Erfahrung kostet das Aufrufen des Modulo-Operators (%) jedoch mehr als der Nutzen, den man erhält. Daher verwende ich Bit-Tricks mit 255 = 2 ^ 8-1, um den Rest zu berechnen. (Zum Guten oder Schlechten verwende ich nicht den Trick, einzelne Bytes aus einem Wort zu lesen, sondern nur bitweise und und verschiebt sich.)

   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.

   Um tatsächlich zu überprüfen, ob der Rest ein Quadrat ist, schlage ich die Antwort in einer vorberechneten Tabelle nach.

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

3. Versuchen Sie abschließend, die Quadratwurzel mit einer Methode zu berechnen, die Hensels Lemma ähnelt . (Ich denke nicht, dass es direkt anwendbar ist, aber es funktioniert mit einigen Modifikationen.) Bevor ich das mache, teile ich alle Zweierpotenzen mit einer binären Suche auf:

   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;

   Zu diesem Zeitpunkt muss unsere Zahl 1 Mod 8 sein, damit unsere Zahl ein Quadrat ist.

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

   Die Grundstruktur von Hensels Lemma ist die folgende. (Hinweis: ungetesteter Code; wenn er nicht funktioniert, versuchen Sie es mit t = 2 oder 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.

   Die Idee ist, dass Sie bei jeder Iteration ein Bit zu r hinzufügen, der "aktuellen" Quadratwurzel von x; Jede Quadratwurzel ist genau modulo eine immer größere Potenz von 2, nämlich t / 2. Am Ende sind r und t / 2-r Quadratwurzeln von x modulo t / 2. (Beachten Sie, dass, wenn r eine Quadratwurzel von x ist, dies auch -r ist. Dies gilt auch für Modulo-Zahlen, aber Vorsicht, Modulo einige Zahlen, Dinge können sogar mehr als 2 Quadratwurzeln haben, insbesondere schließt dies Potenzen von 2 ein. ) Da unsere tatsächliche Quadratwurzel kleiner als 2 ^ 32 ist, können wir an diesem Punkt tatsächlich nur überprüfen, ob r oder t / 2-r echte Quadratwurzeln sind. In meinem eigentlichen Code verwende ich die folgende modifizierte Schleife:

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

   Die Beschleunigung wird hier auf drei Arten erzielt: vorberechneter Startwert (entspricht ~ 10 Iterationen der Schleife), früheres Verlassen der Schleife und Überspringen einiger t-Werte. Für den letzten Teil schaue ich z = r - x * xund setze t mit einem kleinen Trick als die größte Potenz von 2, die z teilt. Dadurch kann ich t-Werte überspringen, die den Wert von r ohnehin nicht beeinflusst hätten. Der vorberechnete Startwert in meinem Fall wählt das "kleinste positive" Quadratwurzelmodulo 8192 aus.

Auch wenn dieser Code für Sie nicht schneller funktioniert, hoffe ich, dass Ihnen einige der darin enthaltenen Ideen gefallen. Es folgt ein vollständiger, getesteter Code, einschließlich der vorberechneten Tabellen.

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

Ich bin ziemlich spät zur Party, aber ich hoffe, eine bessere Antwort zu geben; kürzer und (vorausgesetzt mein Benchmark ist korrekt) auch viel schneller .

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

Der erste Test fängt die meisten Nichtquadrate schnell ab. Es wird eine Tabelle mit 64 Elementen verwendet, die in einer langen Tabelle gepackt ist, sodass keine Kosten für den Arrayzugriff anfallen (Indirektion und Grenzüberprüfung). Für einen einheitlich zufälligen Zufall longbesteht eine Wahrscheinlichkeit von 81,25%, hier zu enden.

Der zweite Test erfasst alle Zahlen mit einer ungeraden Anzahl von Zweien in ihrer Faktorisierung. Die Methode Long.numberOfTrailingZerosist sehr schnell, da sie JIT-ed in einen einzelnen i86-Befehl umwandelt.

Nach dem Löschen der nachfolgenden Nullen behandelt der dritte Test Zahlen, die mit 011, 101 oder 111 in Binärform enden und keine perfekten Quadrate sind. Es kümmert sich auch um negative Zahlen und behandelt auch 0.

Der letzte Test fällt auf die doubleArithmetik zurück. Da doublenur 53-Bit-Mantisse vorhanden ist, umfasst die Konvertierung von longnach doubleeine Rundung für große Werte. Trotzdem ist der Test korrekt (es sei denn, der Beweis ist falsch).

Der Versuch, die Idee von mod255 zu integrieren, war nicht erfolgreich.

Sie müssen ein Benchmarking durchführen. Der beste Algorithmus hängt von der Verteilung Ihrer Eingaben ab.

Ihr Algorithmus ist möglicherweise nahezu optimal, Sie sollten jedoch eine schnelle Überprüfung durchführen, um einige Möglichkeiten auszuschließen, bevor Sie Ihre Quadratwurzel-Routine aufrufen. Schauen Sie sich zum Beispiel die letzte Ziffer Ihrer Zahl in hexadezimaler Form an, indem Sie ein bisschen "und" eingeben. Perfekte Quadrate können nur mit 0, 1, 4 oder 9 in Basis 16 enden. Für 75% Ihrer Eingaben (vorausgesetzt, sie sind gleichmäßig verteilt) können Sie einen Aufruf der Quadratwurzel im Austausch für ein sehr schnelles Bit-Twiddling vermeiden.

Kip hat den folgenden Code mit dem Hex-Trick verglichen. Beim Testen der Nummern 1 bis 100.000.000 lief dieser Code doppelt so schnell wie das 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;
    }
}

Als ich den analogen Code in C ++ getestet habe, lief er tatsächlich langsamer als das Original. Als ich jedoch die switch-Anweisung eliminierte, machte der Hex-Trick den Code erneut doppelt so schnell.

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

Das Eliminieren der switch-Anweisung hatte nur geringe Auswirkungen auf den C # -Code.

Ich dachte an die schrecklichen Zeiten, die ich im Kurs Numerische Analyse verbracht habe.

Und dann erinnere ich mich, dass diese Funktion aus dem Quake-Quellcode im Netz kreiste:

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

Was im Grunde genommen eine Quadratwurzel unter Verwendung der Newtonschen Approximationsfunktion berechnet (ich kann mich nicht an den genauen Namen erinnern).

Es sollte brauchbar sein und könnte sogar schneller sein, es stammt aus einem der phänomenalen ID-Software-Spiele!

Es ist in C ++ geschrieben, aber es sollte nicht zu schwierig sein, dieselbe Technik in Java wiederzuverwenden, sobald Sie die Idee haben:

Ich fand es ursprünglich unter: http://www.codemaestro.com/reviews/9

Newtons Methode wird auf Wikipedia erklärt: http://en.wikipedia.org/wiki/Newton%27s_method

Sie können dem Link folgen, um weitere Erklärungen zur Funktionsweise zu erhalten. Wenn Sie sich jedoch nicht viel darum kümmern, ist dies ungefähr das, woran ich mich beim Lesen des Blogs und beim Besuch des Kurses für numerische Analyse erinnere:

• das * (long*) &y ist im Prinzip eine schnelle convert-to-Funktion so lange Ganzzahl - Operationen an den unformatierten Bytes angewendet werden kann.
• Die 0x5f3759df - (i >> 1);Linie ist ein vorberechneter Startwert für die Approximationsfunktion.
• das * (float*) &i konvertiert den Wert zurück in Gleitkomma.
• Die y = y * ( threehalfs - ( x2 * y * y ) )Zeile iteriert den Wert erneut grundlegend über die Funktion.

Die Approximationsfunktion liefert genauere Werte, je mehr Sie die Funktion über das Ergebnis iterieren. In Quakes Fall ist eine Iteration "gut genug", aber wenn Sie nicht wären ... dann könnten Sie so viel Iteration hinzufügen, wie Sie benötigen.

Dies sollte schneller sein, da dadurch die Anzahl der Divisionsoperationen, die beim naiven Quadratwurzeln ausgeführt werden, auf eine einfache Division durch 2 reduziert wird (eigentlich eine * 0.5FMultiplikationsoperation) und stattdessen durch einige feste Multiplikationsoperationen ersetzt wird.

Ich bin mir nicht sicher, ob es schneller oder sogar genauer wäre, aber Sie könnten John Carmacks Magical Square Root- Algorithmus verwenden, um die Quadratwurzel schneller zu lösen. Sie könnten dies wahrscheinlich leicht für alle möglichen 32-Bit-Ganzzahlen testen und überprüfen, ob Sie tatsächlich korrekte Ergebnisse erhalten haben, da dies nur eine Annäherung ist. Jetzt, wo ich darüber nachdenke, ist die Verwendung von Doppel auch ungefähr, daher bin ich mir nicht sicher, wie das ins Spiel kommen würde.

Wenn Sie einen binären Schnitt ausführen, um die "richtige" Quadratwurzel zu finden, können Sie ziemlich leicht feststellen, ob der Wert, den Sie haben, nahe genug ist, um Folgendes zu erkennen:

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

Nach der Berechnung n^2stehen folgende Optionen zur Verfügung:

• n^2 = target: erledigt, return true
• n^2 + 2n + 1 > target > n^2 : Sie sind nah dran, aber es ist nicht perfekt: Geben Sie false zurück
• n^2 - 2n + 1 < target < n^2 : dito
• target < n^2 - 2n + 1 : binärer Chop auf einem niedrigeren n
• target > n^2 + 2n + 1 : binärer Chop auf einem höheren n

(Entschuldigung, dies wird nals Ihre aktuelle Vermutung und targetfür den Parameter verwendet. Entschuldigen Sie die Verwirrung!)

Ich weiß nicht, ob das schneller geht oder nicht, aber es ist einen Versuch wert.

BEARBEITEN: Der binäre Chop muss auch nicht den gesamten Bereich von ganzen Zahlen (2^x)^2 = 2^(2x)berücksichtigen. Wenn Sie also das oberste gesetzte Bit in Ihrem Ziel gefunden haben (was mit einem Trick gemacht werden kann; ich vergesse genau, wie) Sie können schnell eine Reihe möglicher Antworten erhalten. Wohlgemerkt, ein naiver binärer Chop dauert immer noch nur bis zu 31 oder 32 Iterationen.

Ich habe meine eigene Analyse mehrerer Algorithmen in diesem Thread durchgeführt und einige neue Ergebnisse erzielt. Sie können diese alten Ergebnisse im Bearbeitungsverlauf dieser Antwort sehen, aber sie sind nicht korrekt, da ich einen Fehler gemacht habe und Zeit damit verschwendet habe, mehrere Algorithmen zu analysieren, die nicht in der Nähe sind. Da ich jedoch Lehren aus verschiedenen Antworten gezogen habe, habe ich jetzt zwei Algorithmen, die den "Gewinner" dieses Threads vernichten. Hier ist das Kernstück, das ich anders mache als alle anderen:

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

Diese einfache Zeile, die meistens ein oder zwei sehr schnelle Anweisungen hinzufügt, vereinfacht das jedoch erheblich switch-case Anweisung jedoch zu einer if-Anweisung. Es kann jedoch zur Laufzeit beitragen, wenn viele der getesteten Zahlen signifikante Zweierpotenzfaktoren aufweisen.

Die folgenden Algorithmen sind wie folgt:

• Internet - Kips Antwort
• Durron - Meine modifizierte Antwort unter Verwendung der One-Pass-Antwort als Basis
• DurronTwo - Meine geänderte Antwort mit der Zwei-Pass-Antwort (von @JohnnyHeggheim), mit einigen anderen geringfügigen Änderungen.

Hier ist eine Beispiellaufzeit, wenn die Zahlen mit generiert werden 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

Und hier ist eine Beispiellaufzeit, wenn sie nur auf den ersten Millionen Longs ausgeführt wird:

 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

Wie Sie sehen können, DurronTwoeignet es sich besser für große Eingaben, da der Zaubertrick sehr oft verwendet wird, aber im Vergleich zum ersten Algorithmus überlastet wird und Math.sqrtdie Zahlen so viel kleiner sind. Inzwischen ist das einfacherDurron ein großer Gewinner, da er in den ersten Millionen Zahlen nie viele Male durch 4 dividieren muss.

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

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

Und mein Benchmark-Gurt: (Benötigt 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: Ich habe einen neuen Algorithmus entwickelt, der in einigen Szenarien schneller und in anderen langsamer ist. Ich habe unterschiedliche Benchmarks basierend auf unterschiedlichen Eingaben erhalten. Wenn wir Modulo berechnen 0xFFFFFF = 3 x 3 x 5 x 7 x 13 x 17 x 241, können wir 97,82% der Zahlen eliminieren, die keine Quadrate sein können. Dies kann (irgendwie) in einer Zeile mit 5 bitweisen Operationen erfolgen:

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

Der resultierende Index ist entweder 1) der Rückstand, 2) der Rückstand + 0xFFFFFFoder 3) der Rückstand + 0x1FFFFFE. Natürlich brauchen wir eine Nachschlagetabelle für Reste Modulo 0xFFFFFF, bei der es sich um eine 3-MB-Datei handelt (in diesem Fall als ASCII-Text-Dezimalzahlen gespeichert, nicht optimal, aber mit a ByteBufferund so weiter eindeutig verbesserbar . Aber da dies eine Vorberechnung ist, ist dies nicht der Fall.) Es ist nicht so wichtig. Sie können die Datei hier finden (oder selbst generieren):

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

Ich lade es in ein booleanArray wie folgt:

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

Beispiel Laufzeit. Es schlug Durron(Version eins) in jedem Versuch, den ich lief.

 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

Es sollte viel schneller sein, die Newtonsche Methode zur Berechnung der ganzzahligen Quadratwurzel zu verwenden, diese Zahl dann zu quadrieren und zu überprüfen, wie Sie es in Ihrer aktuellen Lösung tun. Die Newtonsche Methode ist die Grundlage für die in einigen anderen Antworten erwähnte Carmack-Lösung. Sie sollten in der Lage sein, eine schnellere Antwort zu erhalten, da Sie nur an dem ganzzahligen Teil der Wurzel interessiert sind, sodass Sie den Approximationsalgorithmus früher stoppen können.

Eine weitere Optimierung, die Sie ausprobieren können: Wenn die digitale Wurzel einer Zahl nicht mit 1, 4, 7 oder 9 endet, ist die Zahl kein perfektes Quadrat. Dies kann als schnelle Methode verwendet werden, um 60% Ihrer Eingaben zu eliminieren, bevor der langsamere Quadratwurzel-Algorithmus angewendet wird.

Ich möchte, dass diese Funktion mit allen positiven 64-Bit-Ganzzahlen mit Vorzeichen funktioniert

Math.sqrt()funktioniert mit doppelten Eingabeparametern, sodass Sie für Ganzzahlen größer als 2 ^ 53 keine genauen Ergebnisse erhalten .

Ein anderer Ansatz besteht darin, die Hauptzerlegung zu verwenden. Wenn jeder Faktor der Zerlegung gerade ist, ist die Zahl ein perfektes Quadrat. Sie möchten also sehen, ob eine Zahl als Produkt aus Quadraten von Primzahlen zerlegt werden kann. Natürlich müssen Sie eine solche Zerlegung nicht erhalten, nur um zu sehen, ob sie existiert.

Erstellen Sie zuerst eine Tabelle mit Quadraten von Primzahlen, die niedriger als 2 ^ 32 sind. Dies ist weitaus kleiner als eine Tabelle aller Ganzzahlen bis zu dieser Grenze.

Eine Lösung wäre dann:

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

Ich denke, es ist ein bisschen kryptisch. In jedem Schritt wird überprüft, ob das Quadrat einer Primzahl die eingegebene Zahl teilt. Wenn dies der Fall ist, wird die Zahl so lange wie möglich durch das Quadrat geteilt, um dieses Quadrat aus der Hauptzerlegung zu entfernen. Wenn wir durch diesen Prozess zu 1 kamen, war die eingegebene Zahl eine Zerlegung des Quadrats der Primzahlen. Wenn das Quadrat größer als die Zahl selbst wird, kann dieses Quadrat oder größere Quadrate es auf keinen Fall teilen, sodass die Zahl keine Zerlegung von Quadraten von Primzahlen sein kann.

Angesichts der heutigen Hardware und der Notwendigkeit, hier Primzahlen zu berechnen, ist diese Lösung wahrscheinlich viel langsamer. Aber es sollte bessere Ergebnisse liefern als eine Lösung mit sqrt, die über 2 ^ 54 nicht funktioniert, wie mrzl in seiner Antwort sagt.

Es wurde darauf hingewiesen, dass die letzten dZiffern eines perfekten Quadrats nur bestimmte Werte annehmen können. Die letzten dZiffern (in der Basis b) einer Zahl nsind die gleichen wie der Rest, wenn sie ndurch geteilt werden bd, d. H. in C-Notation n % pow(b, d).

Dies kann auf jeden Modul verallgemeinert werden m, dh. n % mkann verwendet werden, um einen bestimmten Prozentsatz von Zahlen als perfekte Quadrate auszuschließen. Der Modul, den Sie derzeit verwenden, ist 64, was 12 erlaubt, dh. 19% der Reste als mögliche Quadrate. Mit ein wenig Codierung fand ich den Modul 110880, der nur 2016 erlaubt, dh. 1,8% der verbleibenden Quadrate. Abhängig von den Kosten einer Moduloperation (dh Division) und einer Tabellensuche im Vergleich zu einer Quadratwurzel auf Ihrem Computer ist die Verwendung dieses Moduls möglicherweise schneller.

Übrigens, wenn Java eine Möglichkeit hat, ein gepacktes Array von Bits für die Nachschlagetabelle zu speichern, verwenden Sie es nicht. 110880 32-Bit-Wörter sind heutzutage nicht viel RAM und das Abrufen eines Maschinenworts ist schneller als das Abrufen eines einzelnen Bits.

Ein ganzzahliges Problem verdient eine ganzzahlige Lösung. Somit

Führen Sie eine binäre Suche nach den (nicht negativen) Ganzzahlen durch, um die größte Ganzzahl t so zu finden, dass t**2 <= n. Dann testen Sie ob r**2 = ngenau. Dies dauert einige Zeit O (log n).

Wenn Sie nicht wissen, wie man die positiven ganzen Zahlen binär durchsucht, weil die Menge unbegrenzt ist, ist es einfach. Sie beginnen mit der Berechnung Ihrer zunehmenden Funktion f (oben f(t) = t**2 - n) auf Zweierpotenzen. Wenn Sie sehen, dass es positiv wird, haben Sie eine Obergrenze gefunden. Dann können Sie eine standardmäßige binäre Suche durchführen.

Die folgende Vereinfachung der Lösung von maaartinus scheint die Laufzeit um einige Prozentpunkte zu verkürzen, aber ich bin nicht gut genug im Benchmarking, um einen Benchmark zu erstellen, dem ich vertrauen kann:

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

Es lohnt sich zu prüfen, wie der erste Test weggelassen wird.

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

würde die Leistung beeinträchtigen.

Für die Leistung müssen Sie sehr oft einige Komprimierungen durchführen. Andere haben verschiedene Methoden ausgedrückt. Sie haben jedoch festgestellt, dass Carmacks Hack bis zu bestimmten Werten von N schneller war. Dann sollten Sie das "n" überprüfen. Wenn es kleiner als diese Zahl N ist, verwenden Sie Carmacks Hack, andernfalls verwenden Sie eine andere beschriebene Methode in den Antworten hier.

Dies ist die schnellste Java-Implementierung, die ich mit einer Kombination von Techniken entwickeln konnte, die von anderen in diesem Thread vorgeschlagen wurden.

• Mod-256 Test
• Ungenauer Mod-3465-Test (vermeidet die Ganzzahldivision auf Kosten einiger falsch positiver Ergebnisse)
• Gleitkomma-Quadratwurzel, runden und mit dem Eingabewert vergleichen

Ich habe auch mit diesen Modifikationen experimentiert, aber sie haben die Leistung nicht verbessert:

• Zusätzlicher Mod-255-Test
• Teilen des Eingabewerts durch Potenzen von 4
• Schnelle inverse Quadratwurzel (um für hohe Werte von N zu arbeiten, sind 3 Iterationen erforderlich, genug, um sie langsamer als die Hardware-Quadratwurzelfunktion zu machen.)

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

}