Math.clz32()

x

Eine Zahl.

Die Anzahl der führenden Nullbits in der 32-Bit-Binärdarstellung von x.

clz32 steht für CountLeadingZeros32.

Wenn x keine Zahl ist, wird sie zuerst in eine Zahl umgewandelt und dann in eine 32-Bit-Unsigned Integer konvertiert.

Wenn das konvertierte 32-Bit-Unsigned Integer 0 ist, wird 32 zurückgegeben, da alle Bits 0 sind. Wenn das höchstwertige Bit 1 ist (d.h. die Zahl ist größer oder gleich 2³¹), wird 0 zurückgegeben.

Diese Funktion ist besonders nützlich für Systeme, die in JS kompiliert werden, wie Emscripten.

Derzeit gibt es kein Math.clon für "Zählen führender Einsen" (genannt "clon", nicht "clo", weil "clo" und "clz" besonders für nicht-englischsprachige Personen zu ähnlich sind). Eine clon-Funktion kann jedoch leicht erstellt werden, indem die Bits einer Zahl invertiert und das Ergebnis an Math.clz32 übergeben wird. Dies funktioniert, weil das Inverse von 1 ist 0 und umgekehrt. Durch Invertieren der Bits wird die gemessene Menge von 0en (von Math.clz32) invertiert, wodurch Math.clz32 die Anzahl der Einsen anstelle der Anzahl der Nullen zählt.

Betrachten Sie das folgende 32-Bit-Wort:

const a = 32776; // 00000000000000001000000000001000 (16 leading zeros)
Math.clz32(a); // 16

const b = ~32776; // 11111111111111110111111111110111 (32776 inverted, 0 leading zeros)
Math.clz32(b); // 0 (this is equal to how many leading one's there are in a)

Unter Verwendung dieser Logik kann eine clon-Funktion wie folgt erstellt werden:

const clz = Math.clz32;

function clon(integer) {
  return clz(~integer);
}

Darüber hinaus könnte diese Technik erweitert werden, um eine sprungfreie Funktion "Zählen der endenden Nullen" zu erstellen, wie unten gezeigt. Die ctrz-Funktion nimmt ein bitweises UND des Integers mit seinem Zweierkomplement. Aufgrund der Funktionsweise des Zweierkomplements werden alle endenden Nullen in Einsen umgewandelt, und dann würde beim Hinzufügen von 1 ein Übertrag bis zum ersten 0 (die ursprünglich eine 1 war) reichen. Alle höheren Bits bleiben gleich und sind Inverse der Bits des ursprünglichen Integers. Daher werden beim bitweisen UND mit dem ursprünglichen Integer alle höheren Bits zu 0, die mit clz gezählt werden können. Die Anzahl der Endnullen plus das erste 1-Bit plus die führenden Bits, die von clz gezählt wurden, ergeben insgesamt 32.

function ctrz(integer) {
  integer >>>= 0; // coerce to Uint32
  if (integer === 0) {
    // skipping this step would make it return -1
    return 32;
  }
  integer &= -integer; // equivalent to `int = int & (~int + 1)`
  return 31 - clz(integer);
}

Dann können wir eine Funktion "Zählen der endenden Einsen" wie folgt definieren:

function ctron(integer) {
  return ctrz(~integer);
}

Diese Hilfsfunktionen können in ein asm.js-Modul umgewandelt werden, um eine potenzielle Leistungsverbesserung zu erzielen.

const countTrailsMethods = (function (stdlib, foreign, heap) {
  "use asm";
  const clz = stdlib.Math.clz32;

  // count trailing zeros
  function ctrz(integer) {
    integer = integer | 0; // coerce to an integer
    if ((integer | 0) == 0) {
      // skipping this step would make it return -1
      return 32;
    }
    // Note: asm.js doesn't have compound assignment operators such as &=
    integer = integer & -integer; // equivalent to `int = int & (~int + 1)`
    return (31 - clz(integer)) | 0;
  }

  // count trailing ones
  function ctron(integer) {
    integer = integer | 0; // coerce to an integer
    return ctrz(~integer) | 0;
  }

  // asm.js demands plain objects:
  return { ctrz: ctrz, ctron: ctron };
})(window, null, null);

const { ctrz, ctron } = countTrailsMethods;

• Polyfill von Math.clz32 in core-js
• es-shims Polyfill von Math.clz32
• Math
• Math.imul