倍長整数クラスの実装(今更ながらのJava入門) の編集履歴

nishikawa が 2016-04-05 00:58 に編集

--- Ver.4	2015-11-09 10:12:54+09:00
+++ Ver.5	2016-04-05 00:58:54+09:00
@@ -48,21 +48,21 @@
 これを理解していないプログラマは Java プログラムを書く資格がない.
 リファレンスマニュアルで最初に読むべきは Object の頁である.
 
-```
-     1	package org.creasys.numeric;
-     2	
-     3	import java.io.Serializable;
-     4	import java.util.Random;
-     5	import org.creasys.util.Pair;
-     6	
-     7	/**
-     8	 * 倍長整数クラス.
-     9	 * <p>
-    10	 * long 値を 2 個連結し, <code>2 * {@link Long#SIZE}</code> ビットの整数として扱うクラス.
-    11	 *
-    12	 * @author tt &lt;tanimoto@creasys.org&gt;
-    13	 */
-    14	public class LongLong extends Number implements Comparable<LongLong>, Cloneable, Serializable {
+```java linenums:
+package org.creasys.numeric;
+
+import java.io.Serializable;
+import java.util.Random;
+import org.creasys.util.Pair;
+
+/**
+ * 倍長整数クラス.
+ * <p>
+ * long 値を 2 個連結し, <code>2 * {@link Long#SIZE}</code> ビットの整数として扱うクラス.
+ *
+ * @author tt &lt;tanimoto@creasys.org&gt;
+ */
+public class LongLong extends Number implements Comparable<LongLong>, Cloneable, Serializable {
 ```
 
 ## クラスフィールド群.
@@ -76,17 +76,17 @@
 
 これ以外のケースで final はあまり深い意味を持っておらず, 単なる再代入禁止の変数となる.
 
-```
-    16		/** 倍長整数のビット幅. */
-    17		public static final int SIZE = 2 * Long.SIZE;
-    18	
-    19		/** 単精度浮動小数点数で表した基数 (<code>2<sup>{@link #SIZE}</sup></code>). */
-    20		private static final float BASE_F = Math.scalb(1.0F, Long.SIZE);
-    21		/** 倍精度浮動小数点数で表した基数 (<code>2<sup>{@link #SIZE}</sup></code>). */
-    22		private static final double BASE_D = Math.scalb(1.0, Long.SIZE);
-    23	
-    24		/** 乱数発生器. {@link #random()} で使用する. */
-    25		private static Random random = new Random();
+```java linenums:16
+	/** 倍長整数のビット幅. */
+	public static final int SIZE = 2 * Long.SIZE;
+
+	/** 単精度浮動小数点数で表した基数 (<code>2<sup>{@link #SIZE}</sup></code>). */
+	private static final float BASE_F = Math.scalb(1.0F, Long.SIZE);
+	/** 倍精度浮動小数点数で表した基数 (<code>2<sup>{@link #SIZE}</sup></code>). */
+	private static final double BASE_D = Math.scalb(1.0, Long.SIZE);
+
+	/** 乱数発生器. {@link #random()} で使用する. */
+	private static Random random = new Random();
 ```
 
 ## インスタンスフィールド群.
@@ -94,11 +94,11 @@
 インスタンスフィールドは, オブジェクト毎に実体化される変数である. 人クラスと言うものを考えたら,
 名前属性はインスタンスフィールドであるべきである.
 
-```
-    27		/** 下位ワード. */
-    28		private long lo;
-    29		/** 上位ワード. */
-    30		private long hi;
+```java linenums:27
+	/** 下位ワード. */
+	private long lo;
+	/** 上位ワード. */
+	private long hi;
 ```
 
 ## クラスメソッド:random.
@@ -107,7 +107,7 @@
 クラスメソッドは, 特定のインスタンスに紐づかない操作を表現するメソッドで, 利用する場合は,
 (このクラスの外からだと)
 
-```
+```java
 LongLong x = LongLong.random();
 ```
 
@@ -117,19 +117,19 @@
 random メソッドの中に random.nextInt() と言うのが登場するが, こちらの random はフィールドの random
 を意味している. このように Java ではメソッド名とフィールド名が被っていても許される.
 
-```
-    32		/**
-    33		 * ランダムに生成した倍長整数を返す.
-    34		 *
-    35		 * @return 生成した倍長整数
-    36		 */
-    37		public static LongLong random() {
-    38			long xLo = random.nextInt() & 0xFFFFFFFFL;
-    39			xLo |= random.nextInt() << 32;
-    40			long xHi = random.nextInt() & 0xFFFFFFFFL;
-    41			xHi |= random.nextInt() << 32;
-    42			return new LongLong(xLo, xHi);
-    43		}
+```java linenums:32
+	/**
+	 * ランダムに生成した倍長整数を返す.
+	 *
+	 * @return 生成した倍長整数
+	 */
+	public static LongLong random() {
+		long xLo = random.nextInt() & 0xFFFFFFFFL;
+		xLo |= random.nextInt() << 32;
+		long xHi = random.nextInt() & 0xFFFFFFFFL;
+		xHi |= random.nextInt() << 32;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## コンストラクタ.
@@ -142,443 +142,443 @@
 この倍長整数オブジェクトは, 不変オブジェクトとして設計しているので, コンストラクタで初期化した
 lo, hi フィールドは, オブジェクトが破棄されるまで別の値を再設定されることはない.
 
-```
-    45		/**
-    46		 * 長整数を値とする倍長整数を構築する.
-    47		 *
-    48		 * @param value 値
-    49		 */
-    50		public LongLong(long value) {
-    51			this.lo = value;
-    52			this.hi = value >= 0 ? 0 : -1L;
-    53		}
+```java linenums:45
+	/**
+	 * 長整数を値とする倍長整数を構築する.
+	 *
+	 * @param value 値
+	 */
+	public LongLong(long value) {
+		this.lo = value;
+		this.hi = value >= 0 ? 0 : -1L;
+	}
 ```
 
 ## 非公開コンストラクタ.
 
 非公開なので, クラス外からは利用できないコンストラクタである.
 
-```
-    55		/**
-    56		 * 下位ワード, 上位ワードを指定して倍長整数を構築する.
-    57		 *
-    58		 * @param lo 下位ワード値
-    59		 * @param hi 上位ワード値
-    60		 */
-    61		private LongLong(long lo, long hi) {
-    62			this.lo = lo;
-    63			this.hi = hi;
-    64		}
+```java linenums:55
+	/**
+	 * 下位ワード, 上位ワードを指定して倍長整数を構築する.
+	 *
+	 * @param lo 下位ワード値
+	 * @param hi 上位ワード値
+	 */
+	private LongLong(long lo, long hi) {
+		this.lo = lo;
+		this.hi = hi;
+	}
 ```
 
 以降は, 読めば理解できるのではないかと思うので, くどい解説はしない.
 
 ## メソッド:add.
 
-```
-    66		/**
-    67		 * この倍長整数と与えられた倍長整数の加算を行い, 結果を返す.
-    68		 * <p>
-    69		 * オーバフローは無視する.
-    70		 * <p>
-    71		 * 繰り上がり処理の方法はいくつかある.
-    72		 * <ol>
-    73		 * <li>符号なし整数型をサポートする C/C++ などの場合:<pre>
-    74		 *      uint32_t xLo = aLo + bLo;
-    75		 *      int32_t xHi = aHi + bHi;
-    76		 *      if (xLo &lt; aLo)
-    77		 *          ++xHi;</pre>
-    78		 * <li>使用しているワードより高精度の整数を利用:<pre>
-    79		 *      uint64_t t = (uint64_t) aLo + bLo;
-    80		 *      uint32_t xLo = (uint32_t) t;
-    81		 *      int32_t xHi = aHi + bHi + (int32_t) (t &gt;&gt; 32);</pre>
-    82		 * <li>ハードウェア的な発想:<pre>
-    83		 *      uint32_t xLo = aLo + bLo;
-    84		 *      int32_t xHi = aHi + bHi + ((aLo &amp; bLo | (aLo | bLo) &amp; ~xLo) &gt;&gt; 31);</pre>
-    85		 * </ol>
-    86		 * ここでは, 最後の方法をより素直な表現で実装している. 分岐が多いため, 実行効率は良くない.
-    87		 *
-    88		 * @param b 加数
-    89		 * @return 加算結果
-    90		 */
-    91		public LongLong add(LongLong b) {
-    92			long xLo = lo + b.lo;
-    93			long xHi = hi + b.hi;
-    94			if (lo < 0 && b.lo < 0 ||
-    95					(lo < 0 || b.lo < 0) && xLo >= 0)
-    96				// 下位ワードから繰り上がり.
-    97				++xHi;
-    98			return new LongLong(xLo, xHi);
-    99		}
+```java linenums:66
+	/**
+	 * この倍長整数と与えられた倍長整数の加算を行い, 結果を返す.
+	 * <p>
+	 * オーバフローは無視する.
+	 * <p>
+	 * 繰り上がり処理の方法はいくつかある.
+	 * <ol>
+	 * <li>符号なし整数型をサポートする C/C++ などの場合:<pre>
+	 *      uint32_t xLo = aLo + bLo;
+	 *      int32_t xHi = aHi + bHi;
+	 *      if (xLo &lt; aLo)
+	 *          ++xHi;</pre>
+	 * <li>使用しているワードより高精度の整数を利用:<pre>
+	 *      uint64_t t = (uint64_t) aLo + bLo;
+	 *      uint32_t xLo = (uint32_t) t;
+	 *      int32_t xHi = aHi + bHi + (int32_t) (t &gt;&gt; 32);</pre>
+	 * <li>ハードウェア的な発想:<pre>
+	 *      uint32_t xLo = aLo + bLo;
+	 *      int32_t xHi = aHi + bHi + ((aLo &amp; bLo | (aLo | bLo) &amp; ~xLo) &gt;&gt; 31);</pre>
+	 * </ol>
+	 * ここでは, 最後の方法をより素直な表現で実装している. 分岐が多いため, 実行効率は良くない.
+	 *
+	 * @param b 加数
+	 * @return 加算結果
+	 */
+	public LongLong add(LongLong b) {
+		long xLo = lo + b.lo;
+		long xHi = hi + b.hi;
+		if (lo < 0 && b.lo < 0 ||
+				(lo < 0 || b.lo < 0) && xLo >= 0)
+			// 下位ワードから繰り上がり.
+			++xHi;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:sub.
 
-```
-   101		/**
-   102		 * 倍長整数同士の減算を行う.
-   103		 * <p>
-   104		 * オーバフローは無視する.
-   105		 *
-   106		 * @param b 減数
-   107		 * @return 減算結果
-   108		 */
-   109		public LongLong sub(LongLong b) {
-   110			long xLo = lo - b.lo;
-   111			long xHi = hi - b.hi;
-   112			if (lo >= 0 && b.lo < 0 ||
-   113					(lo >= 0 || b.lo < 0) && xLo < 0)
-   114				// 下位ワードへの貸し.
-   115				--xHi;
-   116			return new LongLong(xLo, xHi);
-   117		}
+```java linenums:101
+	/**
+	 * 倍長整数同士の減算を行う.
+	 * <p>
+	 * オーバフローは無視する.
+	 *
+	 * @param b 減数
+	 * @return 減算結果
+	 */
+	public LongLong sub(LongLong b) {
+		long xLo = lo - b.lo;
+		long xHi = hi - b.hi;
+		if (lo >= 0 && b.lo < 0 ||
+				(lo >= 0 || b.lo < 0) && xLo < 0)
+			// 下位ワードへの貸し.
+			--xHi;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:mul.
 
-```
-   119		/**
-   120		 * この倍長整数と指定された倍長整数とで乗算を実行し, 結果を返す.
-   121		 *
-   122		 * <p>オーバフローは無視する.
-   123		 *
-   124		 * <p><b>アルゴリズム:</b>
-   125		 * <blockquote>{@code 積和処理:ワード×ワード+ワード→倍長ワード}</blockquote>
-   126		 * の計算をすべて符号なしで行うメソッドを利用する.
-   127		 *
-   128		 * <p>倍長ワードの被乗数と乗数をそれぞれ
-   129		 * <blockquote><code>a = a<sub>L</sub> + a<sub>H</sub> * BASE</code>,<br>
-   130		 * <code>b = b<sub>L</sub> + b<sub>H</sub> * BASE</code></blockquote>
-   131		 * とすると, 乗算結果 {@code x} は,
-   132		 * <blockquote><table>
-   133		 * <tr><td><code>x</code></td><td colspan="2"><code>= x<sub>L</sub> + x<sub>H</sub> *
-   134		 * BASE</code></td></tr>
-   135		 * <tr><td></td><td colspan="2"><code>= a * b</code></td></tr>
-   136		 * <tr><td></td><td><code>= a<sub>L</sub> * b<sub>L</sub></code></td><td><code>+ a<sub>H</sub> *
-   137		 * b<sub>L</sub> * BASE</code></td></tr>
-   138		 * <tr><td></td><td></td><td><code>+ a<sub>L</sub> * b<sub>H</sub> * BASE + a<sub>H</sub> *
-   139		 * b<sub>H</sub> * BASE<sup>2</sup></code></td></tr>
-   140		 * <caption></caption></table></blockquote>
-   141		 * となる. 各項を表にすると, 以下の通り.
-   142		 * <blockquote><table border="1">
-   143		 * <tr><td width="50%" colspan="2">a<sub>L</sub> * b<sub>L</sub></td><td width="25%">&nbsp;</td>
-   144		 * <td width="25%">&nbsp;</td></tr>
-   145		 * <tr><td width="25%">&nbsp;</td><td colspan="2">a<sub>H</sub> * b<sub>L</sub></td>
-   146		 * <td>&nbsp;</td></tr>
-   147		 * <tr><td>&nbsp;</td><td colspan="2">a<sub>L</sub> * b<sub>H</sub></td><td>&nbsp;</td></tr>
-   148		 * <tr><td>&nbsp;</td><td>&nbsp;</td><td colspan="2">a<sub>H</sub> * b<sub>H</sub></td></tr>
-   149		 * <tr><td>x<sub>L</sub></td><td>x<sub>H</sub></td><td>&nbsp;</td><td>&nbsp;</td></tr>
-   150		 * <caption></caption></table></blockquote>
-   151		 * このうち, 最後の <code>a<sub>H</sub> * b<sub>H</sub></code> の項は,
-   152		 * オーバフローを無視するので不要である. これをそのまま手順化すると以下のようになる.
-   153		 *
-   154		 * <blockquote><ul>
-   155		 * <li><code>t<sub>0L</sub>:t<sub>0H</sub> ← a<sub>L</sub> * b<sub>L</sub>,</code></li>
-   156		 * <li><code>x<sub>L</sub> ← t<sub>0L</sub>.</code></li>
-   157		 * <li><code>t<sub>1L</sub>:t<sub>1H</sub> ← a<sub>H</sub> * b<sub>L</sub> +
-   158		 * t<sub>0H</sub>.</code></li>
-   159		 * <li><code>x<sub>H</sub> ← t<sub>1L</sub>.</code></li>
-   160		 * <li><code>t<sub>2L</sub>:t<sub>2H</sub> ← a<sub>L</sub> * b<sub>H</sub> +
-   161		 * x<sub>H</sub>.</code></li>
-   162		 * <li><code>x<sub>H</sub> ← t<sub>1L</sub>.</code></li>
-   163		 * </ul></blockquote>
-   164		 * <p>
-   165		 * ワード同士の符号なし乗算結果の下位ワードのみを取り出すと, 符号付き乗算の結果と一致するため,
-   166		 * 特に符号の処理は必要ない.
-   167		 *
-   168		 * @param b 乗数
-   169		 * @return 乗算結果
-   170		 */
-   171		public LongLong mul(LongLong b) {
-   172			long xLo;
-   173			long xHi;
-   174			LongLong da;
-   175			da = mulx(lo, b.lo, 0L, 0L);
-   176			xLo = da.lo;
-   177			da = mulx(hi, b.lo, da.hi, 0L);
-   178			xHi = da.lo;
-   179			da = mulx(lo, b.hi, 0L, xHi);
-   180			xHi = da.lo;
-   181			return new LongLong(xLo, xHi);
-   182		}
+```java linenums:119
+	/**
+	 * この倍長整数と指定された倍長整数とで乗算を実行し, 結果を返す.
+	 *
+	 * <p>オーバフローは無視する.
+	 *
+	 * <p><b>アルゴリズム:</b>
+	 * <blockquote>{@code 積和処理:ワード×ワード+ワード→倍長ワード}</blockquote>
+	 * の計算をすべて符号なしで行うメソッドを利用する.
+	 *
+	 * <p>倍長ワードの被乗数と乗数をそれぞれ
+	 * <blockquote><code>a = a<sub>L</sub> + a<sub>H</sub> * BASE</code>,<br>
+	 * <code>b = b<sub>L</sub> + b<sub>H</sub> * BASE</code></blockquote>
+	 * とすると, 乗算結果 {@code x} は,
+	 * <blockquote><table>
+	 * <tr><td><code>x</code></td><td colspan="2"><code>= x<sub>L</sub> + x<sub>H</sub> *
+	 * BASE</code></td></tr>
+	 * <tr><td></td><td colspan="2"><code>= a * b</code></td></tr>
+	 * <tr><td></td><td><code>= a<sub>L</sub> * b<sub>L</sub></code></td><td><code>+ a<sub>H</sub> *
+	 * b<sub>L</sub> * BASE</code></td></tr>
+	 * <tr><td></td><td></td><td><code>+ a<sub>L</sub> * b<sub>H</sub> * BASE + a<sub>H</sub> *
+	 * b<sub>H</sub> * BASE<sup>2</sup></code></td></tr>
+	 * <caption></caption></table></blockquote>
+	 * となる. 各項を表にすると, 以下の通り.
+	 * <blockquote><table border="1">
+	 * <tr><td width="50%" colspan="2">a<sub>L</sub> * b<sub>L</sub></td><td width="25%">&nbsp;</td>
+	 * <td width="25%">&nbsp;</td></tr>
+	 * <tr><td width="25%">&nbsp;</td><td colspan="2">a<sub>H</sub> * b<sub>L</sub></td>
+	 * <td>&nbsp;</td></tr>
+	 * <tr><td>&nbsp;</td><td colspan="2">a<sub>L</sub> * b<sub>H</sub></td><td>&nbsp;</td></tr>
+	 * <tr><td>&nbsp;</td><td>&nbsp;</td><td colspan="2">a<sub>H</sub> * b<sub>H</sub></td></tr>
+	 * <tr><td>x<sub>L</sub></td><td>x<sub>H</sub></td><td>&nbsp;</td><td>&nbsp;</td></tr>
+	 * <caption></caption></table></blockquote>
+	 * このうち, 最後の <code>a<sub>H</sub> * b<sub>H</sub></code> の項は,
+	 * オーバフローを無視するので不要である. これをそのまま手順化すると以下のようになる.
+	 *
+	 * <blockquote><ul>
+	 * <li><code>t<sub>0L</sub>:t<sub>0H</sub> ← a<sub>L</sub> * b<sub>L</sub>,</code></li>
+	 * <li><code>x<sub>L</sub> ← t<sub>0L</sub>.</code></li>
+	 * <li><code>t<sub>1L</sub>:t<sub>1H</sub> ← a<sub>H</sub> * b<sub>L</sub> +
+	 * t<sub>0H</sub>.</code></li>
+	 * <li><code>x<sub>H</sub> ← t<sub>1L</sub>.</code></li>
+	 * <li><code>t<sub>2L</sub>:t<sub>2H</sub> ← a<sub>L</sub> * b<sub>H</sub> +
+	 * x<sub>H</sub>.</code></li>
+	 * <li><code>x<sub>H</sub> ← t<sub>1L</sub>.</code></li>
+	 * </ul></blockquote>
+	 * <p>
+	 * ワード同士の符号なし乗算結果の下位ワードのみを取り出すと, 符号付き乗算の結果と一致するため,
+	 * 特に符号の処理は必要ない.
+	 *
+	 * @param b 乗数
+	 * @return 乗算結果
+	 */
+	public LongLong mul(LongLong b) {
+		long xLo;
+		long xHi;
+		LongLong da;
+		da = mulx(lo, b.lo, 0L, 0L);
+		xLo = da.lo;
+		da = mulx(hi, b.lo, da.hi, 0L);
+		xHi = da.lo;
+		da = mulx(lo, b.hi, 0L, xHi);
+		xHi = da.lo;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:mulx.
 
-```
-   184		/**
-   185		 * 符号なし長整数の積和処理を行う.
-   186		 * 正確には「長整数×長整数+長整数+長整数→倍長整数」を実行する.
-   187		 * <p>
-   188		 * オーバフローは発生しない. <code>B = 2<sup>Long.SIZE</sup></code>
-   189		 * とすると, 長整数の最大値は <code>U = B - 1</code> なので,
-   190		 *
-   191		 * <blockquote><table><tr><td><code>U * U + U + U</code></td>
-   192		 * <td><code>= (B - 1)<sup>2</sup> + 2 * (B - 1)</code></td></tr>
-   193		 * <tr><td></td><td><code>= B<sup>2</sup> - 1</code></td></tr>
-   194		 * <caption></caption></table></blockquote>
-   195		 * <p>
-   196		 * つまり, 最大でちょうど符号なし倍長整数の最大値となる.
-   197		 *
-   198		 * @param a 被乗数
-   199		 * @param b 乗数
-   200		 * @param c 加数1
-   201		 * @param d 加数2
-   202		 * @return 積和演算結果
-   203		 */
-   204		private static LongLong mulx(long a, long b, long c, long d) {
-   205			int x0 = (int)  c;
-   206			int x1 = (int) (c >>> 32);
-   207			int x2;
-   208			int x3;
-   209			long da;
-   210			da = mulx((int)  a        , (int)  b        , (int)  d         , x0);
-   211			x0 = (int) da;
-   212			da = mulx((int) (a >>> 32), (int)  b        , (int) (da >>> 32), x1);
-   213			x1 = (int) da;
-   214			x2 = (int) (da >>> 32);
-   215			da = mulx((int)  a        , (int) (b >>> 32), (int) (d  >>> 32), x1);
-   216			x1 = (int) da;
-   217			da = mulx((int) (a >>> 32), (int) (b >>> 32), (int) (da >>> 32), x2);
-   218			x2 = (int) da;
-   219			x3 = (int) (da >>> 32);
-   220			return new LongLong(x0 & 0xFFFFFFFFL | (long) x1 << 32, x2 & 0xFFFFFFFFL | (long) x3 << 32);
-   221		}
-   222	
-   223		/**
-   224		 * 符号なし整数の積和演算「整数×整数+整数+整数→長整数」を行う.
-   225		 * <p>
-   226		 * オーバフローは発生しない. <code>B = 2<sup>{@link Integer#SIZE}</sup></code>
-   227		 * とすると, 符号なし整数の最大値は <code>U = B - 1</code> なので,
-   228		 *
-   229		 * <blockquote><table><tr><td><code>U * U + U + U</code></td>
-   230		 * <td><code>= (B - 1)<sup>2</sup> + 2 * (B - 1)</code></td></tr>
-   231		 * <tr><td></td><td><code>= B<sup>2</sup> - 1</code></td></tr>
-   232		 * <caption></caption></table></blockquote>
-   233		 * <p>
-   234		 * つまり, 最大でちょうど符号なし長整数の最大値となる.
-   235		 *
-   236		 * @param a 被乗数
-   237		 * @param b 乗数
-   238		 * @param c 加数1
-   239		 * @param d 加数2
-   240		 * @return 積和演算結果
-   241		 */
-   242		private static long mulx(int a, int b, int c, int d) {
-   243			return (a & 0xFFFFFFFFL) * (b & 0xFFFFFFFFL) + (c & 0xFFFFFFFFL) + (d & 0xFFFFFFFFL);
-   244		}
+```java linenums:184
+	/**
+	 * 符号なし長整数の積和処理を行う.
+	 * 正確には「長整数×長整数+長整数+長整数→倍長整数」を実行する.
+	 * <p>
+	 * オーバフローは発生しない. <code>B = 2<sup>Long.SIZE</sup></code>
+	 * とすると, 長整数の最大値は <code>U = B - 1</code> なので,
+	 *
+	 * <blockquote><table><tr><td><code>U * U + U + U</code></td>
+	 * <td><code>= (B - 1)<sup>2</sup> + 2 * (B - 1)</code></td></tr>
+	 * <tr><td></td><td><code>= B<sup>2</sup> - 1</code></td></tr>
+	 * <caption></caption></table></blockquote>
+	 * <p>
+	 * つまり, 最大でちょうど符号なし倍長整数の最大値となる.
+	 *
+	 * @param a 被乗数
+	 * @param b 乗数
+	 * @param c 加数1
+	 * @param d 加数2
+	 * @return 積和演算結果
+	 */
+	private static LongLong mulx(long a, long b, long c, long d) {
+		int x0 = (int)  c;
+		int x1 = (int) (c >>> 32);
+		int x2;
+		int x3;
+		long da;
+		da = mulx((int)  a        , (int)  b        , (int)  d         , x0);
+		x0 = (int) da;
+		da = mulx((int) (a >>> 32), (int)  b        , (int) (da >>> 32), x1);
+		x1 = (int) da;
+		x2 = (int) (da >>> 32);
+		da = mulx((int)  a        , (int) (b >>> 32), (int) (d  >>> 32), x1);
+		x1 = (int) da;
+		da = mulx((int) (a >>> 32), (int) (b >>> 32), (int) (da >>> 32), x2);
+		x2 = (int) da;
+		x3 = (int) (da >>> 32);
+		return new LongLong(x0 & 0xFFFFFFFFL | (long) x1 << 32, x2 & 0xFFFFFFFFL | (long) x3 << 32);
+	}
+
+	/**
+	 * 符号なし整数の積和演算「整数×整数+整数+整数→長整数」を行う.
+	 * <p>
+	 * オーバフローは発生しない. <code>B = 2<sup>{@link Integer#SIZE}</sup></code>
+	 * とすると, 符号なし整数の最大値は <code>U = B - 1</code> なので,
+	 *
+	 * <blockquote><table><tr><td><code>U * U + U + U</code></td>
+	 * <td><code>= (B - 1)<sup>2</sup> + 2 * (B - 1)</code></td></tr>
+	 * <tr><td></td><td><code>= B<sup>2</sup> - 1</code></td></tr>
+	 * <caption></caption></table></blockquote>
+	 * <p>
+	 * つまり, 最大でちょうど符号なし長整数の最大値となる.
+	 *
+	 * @param a 被乗数
+	 * @param b 乗数
+	 * @param c 加数1
+	 * @param d 加数2
+	 * @return 積和演算結果
+	 */
+	private static long mulx(int a, int b, int c, int d) {
+		return (a & 0xFFFFFFFFL) * (b & 0xFFFFFFFFL) + (c & 0xFFFFFFFFL) + (d & 0xFFFFFFFFL);
+	}
 ```
 
 ## メソッド:div.
 
-```
-   246		/**
-   247		 * 倍長整数同士の除算を実行し, 結果を返す.
-   248		 *
-   249		 * @param b 除数
-   250		 * @return 除算結果
-   251		 */
-   252		public LongLong div(LongLong b) {
-   253			if (b.lo == 0 && b.hi == 0)
-   254				throw new ArithmeticException();
-   255	
-   256			boolean negative = false;
-   257			LongLong a = this;
-   258			if (a.hi < 0) {
-   259				negative = !negative;
-   260				a = a.negate();
-   261			}
-   262			if (b.hi < 0) {
-   263				negative = !negative;
-   264				b = b.negate();
-   265			}
-   266			LongLong x = a.divUnsigned(b);
-   267			if (negative)
-   268				x = x.negate();
-   269			return x;
-   270		}
+```java linenums:246
+	/**
+	 * 倍長整数同士の除算を実行し, 結果を返す.
+	 *
+	 * @param b 除数
+	 * @return 除算結果
+	 */
+	public LongLong div(LongLong b) {
+		if (b.lo == 0 && b.hi == 0)
+			throw new ArithmeticException();
+
+		boolean negative = false;
+		LongLong a = this;
+		if (a.hi < 0) {
+			negative = !negative;
+			a = a.negate();
+		}
+		if (b.hi < 0) {
+			negative = !negative;
+			b = b.negate();
+		}
+		LongLong x = a.divUnsigned(b);
+		if (negative)
+			x = x.negate();
+		return x;
+	}
 ```
 
 ## メソッド:divUnsigned.
 
-```
-   272		/**
-   273		 * 符号なし倍長整数同士の除算を実行する.
-   274		 * <p>
-   275		 * 筆算の方式を 2 進法で行う. 被除数を倍ワードに拡張したものと商ワードを,
-   276		 * 1ビットずつ左にシフトしながら, 拡張被除数の上位ワードから除数が引ければ引き,
-   277		 * 商の最下位ビットを立てる. この操作を商のビット数回繰り返せばよい.
-   278		 * このメソッドでは利用していないが, この操作が終わったとき,
-   279		 * 拡張被除数の上位ワードには余が得られている.
-   280		 * <p>
-   281		 * ビット数分ループするので, 効率は良くないが, 単純かつ確実な方法である.
-   282		 * 少しだけ改良するとすれば,
-   283		 * 拡張被除数をシフトしていくとき下位ビットは使用しなくなっていくため,
-   284		 * この部分に商を入れてしまうと言うトリッキーな方法がよく使われる.
-   285		 * <p>
-   286		 * プロセッサによっては「倍ワード÷ワード→ワード(商)...ワード(余)」を実行する命令を持っているが,
-   287		 * その場合はこの命令を利用すると効率は格段に良くなる.
-   288		 *
-   289		 * @param b 除数
-   290		 * @return 除算結果
-   291		 */
-   292		public LongLong divUnsigned(LongLong b) {
-   293			LongLong l = this;
-   294			LongLong h = new LongLong(0L, 0L);
-   295			LongLong q = new LongLong(0L, 0L);
-   296	
-   297			for (int k = 0; k < SIZE; ++k) {
-   298				// 拡張被除数を1ビット左シフト.
-   299				h = h.shift(1, false);
-   300				if (l.hi < 0)
-   301					h = h.increment();
-   302				l = l.shift(1, false);
-   303	
-   304				// 商をシフト.
-   305				q = q.shift(1, false);
-   306	
-   307				// 拡張被除数の上位ワードから, 除数が引ければ引く.
-   308				if (h.compareUnsigned(b) >= 0) {
-   309					h = h.sub(b);
-   310	
-   311					// 引けた場合は, 商の最下位ビットを立てる.
-   312					q = q.increment();
-   313				}
-   314			}
-   315			return q;
-   316		}
+```java linenums:272
+	/**
+	 * 符号なし倍長整数同士の除算を実行する.
+	 * <p>
+	 * 筆算の方式を 2 進法で行う. 被除数を倍ワードに拡張したものと商ワードを,
+	 * 1ビットずつ左にシフトしながら, 拡張被除数の上位ワードから除数が引ければ引き,
+	 * 商の最下位ビットを立てる. この操作を商のビット数回繰り返せばよい.
+	 * このメソッドでは利用していないが, この操作が終わったとき,
+	 * 拡張被除数の上位ワードには余が得られている.
+	 * <p>
+	 * ビット数分ループするので, 効率は良くないが, 単純かつ確実な方法である.
+	 * 少しだけ改良するとすれば,
+	 * 拡張被除数をシフトしていくとき下位ビットは使用しなくなっていくため,
+	 * この部分に商を入れてしまうと言うトリッキーな方法がよく使われる.
+	 * <p>
+	 * プロセッサによっては「倍ワード÷ワード→ワード(商)...ワード(余)」を実行する命令を持っているが,
+	 * その場合はこの命令を利用すると効率は格段に良くなる.
+	 *
+	 * @param b 除数
+	 * @return 除算結果
+	 */
+	public LongLong divUnsigned(LongLong b) {
+		LongLong l = this;
+		LongLong h = new LongLong(0L, 0L);
+		LongLong q = new LongLong(0L, 0L);
+
+		for (int k = 0; k < SIZE; ++k) {
+			// 拡張被除数を1ビット左シフト.
+			h = h.shift(1, false);
+			if (l.hi < 0)
+				h = h.increment();
+			l = l.shift(1, false);
+
+			// 商をシフト.
+			q = q.shift(1, false);
+
+			// 拡張被除数の上位ワードから, 除数が引ければ引く.
+			if (h.compareUnsigned(b) >= 0) {
+				h = h.sub(b);
+
+				// 引けた場合は, 商の最下位ビットを立てる.
+				q = q.increment();
+			}
+		}
+		return q;
+	}
 ```
 
 ## メソッド:negate.
 
-```
-   318		/**
-   319		 * 倍長整数の符号反転.
-   320		 * <p>
-   321		 * オーバフローは無視する.
-   322		 *
-   323		 * @return 符号反転結果
-   324		 */
-   325		public LongLong negate() {
-   326			long xLo;
-   327			long xHi;
-   328			xLo = -lo;
-   329			xHi = xLo == 0 ? -hi : ~hi;
-   330			return new LongLong(xLo, xHi);
-   331		}
+```java linenums:318
+	/**
+	 * 倍長整数の符号反転.
+	 * <p>
+	 * オーバフローは無視する.
+	 *
+	 * @return 符号反転結果
+	 */
+	public LongLong negate() {
+		long xLo;
+		long xHi;
+		xLo = -lo;
+		xHi = xLo == 0 ? -hi : ~hi;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:increment.
 
-```
-   333		/**
-   334		 * 倍長整数の次の整数を返す.
-   335		 *
-   336		 * @return 次の整数
-   337		 */
-   338		public LongLong increment() {
-   339			long xLo = lo + 1;
-   340			long xHi = hi;
-   341			if (xLo == 0)
-   342				++xHi;
-   343			return new LongLong(xLo, xHi);
-   344		}
+```java linenums:333
+	/**
+	 * 倍長整数の次の整数を返す.
+	 *
+	 * @return 次の整数
+	 */
+	public LongLong increment() {
+		long xLo = lo + 1;
+		long xHi = hi;
+		if (xLo == 0)
+			++xHi;
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:shift.
 
-```
-   346		/**
-   347		 * 倍長整数のシフト演算を行う.
-   348		 *
-   349		 * @param k シフトするビット数. 負の場合は右シフトを意味する.
-   350		 * @param arithmetic 真なら右シフトの場合に算術シフトを指定する. 左シフトの場合は意味を持たない
-   351		 * @return シフト演算結果
-   352		 */
-   353		public LongLong shift(int k, boolean arithmetic) {
-   354			LongLong result;
-   355			if (k > 0)
-   356				result = shiftLeft(k);
-   357			else if (k < 0)
-   358				// 落とし穴アリ.
-   359				// k == Integer.MIN_VALUE だった場合 -k も負のまま.
-   360				// shiftRight はシフト回数を符号なしとして扱っているので問題はない.
-   361				result = shiftRight(-k, arithmetic);
-   362			else
-   363				result = this;
-   364			return result;
-   365		}
+```java linenums:346
+	/**
+	 * 倍長整数のシフト演算を行う.
+	 *
+	 * @param k シフトするビット数. 負の場合は右シフトを意味する.
+	 * @param arithmetic 真なら右シフトの場合に算術シフトを指定する. 左シフトの場合は意味を持たない
+	 * @return シフト演算結果
+	 */
+	public LongLong shift(int k, boolean arithmetic) {
+		LongLong result;
+		if (k > 0)
+			result = shiftLeft(k);
+		else if (k < 0)
+			// 落とし穴アリ.
+			// k == Integer.MIN_VALUE だった場合 -k も負のまま.
+			// shiftRight はシフト回数を符号なしとして扱っているので問題はない.
+			result = shiftRight(-k, arithmetic);
+		else
+			result = this;
+		return result;
+	}
 ```
 
 ## メソッド:shiftLeft.
 
-```
-   367		/**
-   368		 * 倍長整数の左シフトを行う.
-   369		 *
-   370		 * @param k シフトするビット数. 符号なし数と見なす
-   371		 * @return シフト結果
-   372		 */
-   373		private LongLong shiftLeft(int k) {
-   374			long xHi;
-   375			long xLo;
-   376			if (0 <= k && k < Long.SIZE) {
-   377				//                  +----------------+----------------+
-   378				// シフト前         |      上位      |      下位      |
-   379				//            +-----+----------+-----+----------+-----+
-   380				// シフト後   |      上位      |      下位      | 000 |
-   381				//            +----------------+-----+----------+-----+
-   382				//                                   |   64-k   |  k  |
-   383				xHi = hi << k | lo >>> (Long.SIZE - k);
-   384				xLo = lo << k;
-   385			} else if (Long.SIZE <= k && k < 2 * Long.SIZE) {
-   386				//                   +----------------+----------------+
-   387				// シフト前          |      上位      |      下位      |
-   388				//            +------+---------+------+----------------+
-   389				// シフト後   |      下位      | 000000000000000000000 |
-   390				//            +----------------+------+----------------+
-   391				//                             | k-64 |       64       |
-   392				xHi = lo << (k - Long.SIZE);
-   393				xLo = 0L;
-   394			} else {
-   395				xHi = 0L;
-   396				xLo = 0L;
-   397			}
-   398			return new LongLong(xLo, xHi);
-   399		}
+```java linenums:367
+	/**
+	 * 倍長整数の左シフトを行う.
+	 *
+	 * @param k シフトするビット数. 符号なし数と見なす
+	 * @return シフト結果
+	 */
+	private LongLong shiftLeft(int k) {
+		long xHi;
+		long xLo;
+		if (0 <= k && k < Long.SIZE) {
+			//                  +----------------+----------------+
+			// シフト前         |      上位      |      下位      |
+			//            +-----+----------+-----+----------+-----+
+			// シフト後   |      上位      |      下位      | 000 |
+			//            +----------------+-----+----------+-----+
+			//                                   |   64-k   |  k  |
+			xHi = hi << k | lo >>> (Long.SIZE - k);
+			xLo = lo << k;
+		} else if (Long.SIZE <= k && k < 2 * Long.SIZE) {
+			//                   +----------------+----------------+
+			// シフト前          |      上位      |      下位      |
+			//            +------+---------+------+----------------+
+			// シフト後   |      下位      | 000000000000000000000 |
+			//            +----------------+------+----------------+
+			//                             | k-64 |       64       |
+			xHi = lo << (k - Long.SIZE);
+			xLo = 0L;
+		} else {
+			xHi = 0L;
+			xLo = 0L;
+		}
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## メソッド:shiftRight.
 
-```
-   401		/**
-   402		 * 倍長整数の右シフトを行う.
-   403		 *
-   404		 * @param k シフトするビット数. 符号なし数と見なす
-   405		 * @param arithmetic 算術シフトを示す
-   406		 * @return シフト結果
-   407		 */
-   408		private LongLong shiftRight(int k, boolean arithmetic) {
-   409			long xLo;
-   410			long xHi;
-   411			if (0 <= k && k < Long.SIZE) {
-   412				xLo = lo >>> k | hi << (Long.SIZE - k);
-   413				xHi = arithmetic ? hi >> k : hi >>> k;
-   414			} else if (Long.SIZE <= k && k < 2 * Long.SIZE) {
-   415				xLo = arithmetic ? hi >> (k - Long.SIZE) : hi >>> (k - Long.SIZE);
-   416				xHi = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
-   417			} else {
-   418				xLo = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
-   419				xHi = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
-   420			}
-   421			return new LongLong(xLo, xHi);
-   422		}
+```java linenums:401
+	/**
+	 * 倍長整数の右シフトを行う.
+	 *
+	 * @param k シフトするビット数. 符号なし数と見なす
+	 * @param arithmetic 算術シフトを示す
+	 * @return シフト結果
+	 */
+	private LongLong shiftRight(int k, boolean arithmetic) {
+		long xLo;
+		long xHi;
+		if (0 <= k && k < Long.SIZE) {
+			xLo = lo >>> k | hi << (Long.SIZE - k);
+			xHi = arithmetic ? hi >> k : hi >>> k;
+		} else if (Long.SIZE <= k && k < 2 * Long.SIZE) {
+			xLo = arithmetic ? hi >> (k - Long.SIZE) : hi >>> (k - Long.SIZE);
+			xHi = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
+		} else {
+			xLo = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
+			xHi = arithmetic ? hi >> (Long.SIZE - 1) : 0L;
+		}
+		return new LongLong(xLo, xHi);
+	}
 ```
 
 ## Comparable<LongLong>の実装.
 
-```
-   424	//==== Comparable<LongLong>
+```java linenums:424
+//==== Comparable<LongLong>
 ```
 
 ## メソッド:compareTo.
@@ -592,161 +592,161 @@
 ちなみに Java 5 以前はオーバライドだけに使用することになっていたが,
 Java 6 以降はインタフェースの実装にも書くようになったと言う, gdgd な経緯がある.
 
-```
-   426		/**
-   427		 * この倍長整数と指定された倍長整数を自然比較する.
-   428		 *
-   429		 * @param o 比較対象の倍長整数
-   430		 */
-   431		@Override
-   432		public int compareTo(LongLong o) {
-   433			int comparison;
-   434			if (hi == o.hi) {
-   435				if (lo == o.lo)
-   436					// 上位ワードも下位ワードも等しい.
-   437					comparison = 0;
-   438				else
-   439					// 上位ワードの符号とは無関係に下位ワード同士を符号なし数として比較する.
-   440					if (lo < 0 && o.lo >= 0)
-   441						// 負 : 正.
-   442						comparison = +1;
-   443					else if (lo >= 0 && o.lo < 0)
-   444						// 正 : 負.
-   445						comparison = -1;
-   446					else
-   447						// 同符号.
-   448						comparison = lo - o.lo >= 0 ? +1 : -1;
-   449			} else
-   450				// 上位ワードが等しくない.
-   451				// 上位ワード同士で比較する.
-   452				comparison = hi >= o.hi ? +1 : -1;
-   453			return comparison;
-   454		}
+```java linenums:426
+	/**
+	 * この倍長整数と指定された倍長整数を自然比較する.
+	 *
+	 * @param o 比較対象の倍長整数
+	 */
+	@Override
+	public int compareTo(LongLong o) {
+		int comparison;
+		if (hi == o.hi) {
+			if (lo == o.lo)
+				// 上位ワードも下位ワードも等しい.
+				comparison = 0;
+			else
+				// 上位ワードの符号とは無関係に下位ワード同士を符号なし数として比較する.
+				if (lo < 0 && o.lo >= 0)
+					// 負 : 正.
+					comparison = +1;
+				else if (lo >= 0 && o.lo < 0)
+					// 正 : 負.
+					comparison = -1;
+				else
+					// 同符号.
+					comparison = lo - o.lo >= 0 ? +1 : -1;
+		} else
+			// 上位ワードが等しくない.
+			// 上位ワード同士で比較する.
+			comparison = hi >= o.hi ? +1 : -1;
+		return comparison;
+	}
 ```
 
 ## メソッド:compareUnsigned.
 
-```
-   456		public int compareUnsigned(LongLong o) {
-   457			int comparison;
-   458			if (hi == o.hi) {
-   459				if (lo == o.lo)
-   460					comparison = 0;
-   461				else
-   462					if (lo < 0 && o.lo >= 0)
-   463						comparison = +1;
-   464					else if (lo >= 0 && o.lo < 0)
-   465						comparison = -1;
-   466					else
-   467						comparison = lo - o.lo >= 0 ? +1 : -1;
-   468			} else
-   469				if (hi < 0 && o.hi >= 0)
-   470					comparison = +1;
-   471				else if (hi >= 0 && o.hi < 0)
-   472					comparison = -1;
-   473				else
-   474					comparison = hi - o.hi >= 0 ? +1 : -1;
-   475			return comparison;
-   476		}
+```java linenums:456
+	public int compareUnsigned(LongLong o) {
+		int comparison;
+		if (hi == o.hi) {
+			if (lo == o.lo)
+				comparison = 0;
+			else
+				if (lo < 0 && o.lo >= 0)
+					comparison = +1;
+				else if (lo >= 0 && o.lo < 0)
+					comparison = -1;
+				else
+					comparison = lo - o.lo >= 0 ? +1 : -1;
+		} else
+			if (hi < 0 && o.hi >= 0)
+				comparison = +1;
+			else if (hi >= 0 && o.hi < 0)
+				comparison = -1;
+			else
+				comparison = hi - o.hi >= 0 ? +1 : -1;
+		return comparison;
+	}
 ```
 
 ## Numberの拡張.
 
-```
-   478	//==== Number
+```java linenums:478
+//==== Number
 ```
 
 ## メソッド:intValue.
 
-```
-   480		/**
-   481		 * この倍長整数の下位 32 ビットを返す.
-   482		 *
-   483		 * @return 下位 32 ビット
-   484		 */
-   485		@Override
-   486		public int intValue() {
-   487			return (int) lo;
-   488		}
+```java linenums:480
+	/**
+	 * この倍長整数の下位 32 ビットを返す.
+	 *
+	 * @return 下位 32 ビット
+	 */
+	@Override
+	public int intValue() {
+		return (int) lo;
+	}
 ```
 
 ## メソッド:longValue.
 
-```
-   490		/**
-   491		 * この倍長整数の下位 64 ビットを返す.
-   492		 *
-   493		 * @return 下位 64 ビット
-   494		 */
-   495		@Override
-   496		public long longValue() {
-   497			return lo;
-   498		}
+```java linenums:490
+	/**
+	 * この倍長整数の下位 64 ビットを返す.
+	 *
+	 * @return 下位 64 ビット
+	 */
+	@Override
+	public long longValue() {
+		return lo;
+	}
 ```
 
 ## メソッド:floatValue.
 
-```
-   500		/**
-   501		 * この倍長整数の値を単精度浮動小数点数として返す.
-   502		 *
-   503		 * <p><b>バグ入り注意.</b>
-   504		 *
-   505		 * @return 単精度浮動小数点数で表した値
-   506		 */
-   507		public float floatValueNaive() {
-   508			float x;
-   509			if (lo >= 0)
-   510				x = hi * BASE_F + lo;
-   511			else
-   512				x = hi * BASE_F + (lo + BASE_F);
-   513			return x;
-   514		}
-   515	
-   516		/**
-   517		 * この倍長整数の値を単精度浮動小数点数として返す.
-   518		 *
-   519		 * <p>数学的には <code>(符号付き)上位ワード * 2<sup>64</sup> + (符号なし)下位ワード</code>
-   520		 * を返せばよいが, そのまま実装すると精度が悪い.
-   521		 *
-   522		 * @return 単精度浮動小数点数で表した値
-   523		 */
-   524		@Override
-   525		public float floatValue() {
-   526			LongLong abs = hi >= 0 ? this : negate();
-   527			float x = abs.lo >= 0
-   528					? abs.hi * BASE_F + abs.lo
-   529					: abs.hi * BASE_F + (abs.lo + BASE_F);
-   530			if (hi < 0)
-   531				x = -x;
-   532			return x;
-   533		}
+```java linenums:500
+	/**
+	 * この倍長整数の値を単精度浮動小数点数として返す.
+	 *
+	 * <p><b>バグ入り注意.</b>
+	 *
+	 * @return 単精度浮動小数点数で表した値
+	 */
+	public float floatValueNaive() {
+		float x;
+		if (lo >= 0)
+			x = hi * BASE_F + lo;
+		else
+			x = hi * BASE_F + (lo + BASE_F);
+		return x;
+	}
+
+	/**
+	 * この倍長整数の値を単精度浮動小数点数として返す.
+	 *
+	 * <p>数学的には <code>(符号付き)上位ワード * 2<sup>64</sup> + (符号なし)下位ワード</code>
+	 * を返せばよいが, そのまま実装すると精度が悪い.
+	 *
+	 * @return 単精度浮動小数点数で表した値
+	 */
+	@Override
+	public float floatValue() {
+		LongLong abs = hi >= 0 ? this : negate();
+		float x = abs.lo >= 0
+				? abs.hi * BASE_F + abs.lo
+				: abs.hi * BASE_F + (abs.lo + BASE_F);
+		if (hi < 0)
+			x = -x;
+		return x;
+	}
 ```
 
 ## メソッド:doubleValue.
 
-```
-   535		/**
-   536		 * この倍長整数の値を倍精度浮動小数点数として返す.
-   537		 *
-   538		 * @return 倍精度浮動小数点数で表した値
-   539		 */
-   540		@Override
-   541		public double doubleValue() {
-   542			LongLong abs = hi >= 0 ? this : negate();
-   543			double x = abs.lo >= 0
-   544					? abs.hi * BASE_D + abs.lo
-   545					: abs.hi * BASE_D + abs.lo + BASE_D;
-   546			if (hi < 0)
-   547				x = -x;
-   548			return x;
-   549		}
+```java linenums:535
+	/**
+	 * この倍長整数の値を倍精度浮動小数点数として返す.
+	 *
+	 * @return 倍精度浮動小数点数で表した値
+	 */
+	@Override
+	public double doubleValue() {
+		LongLong abs = hi >= 0 ? this : negate();
+		double x = abs.lo >= 0
+				? abs.hi * BASE_D + abs.lo
+				: abs.hi * BASE_D + abs.lo + BASE_D;
+		if (hi < 0)
+			x = -x;
+		return x;
+	}
 ```
 
 ## Objectの拡張.
 
-```
-   551	//==== Object
+```java linenums:551
+//==== Object
 ```
 
 ## メソッド:clone.
@@ -757,65 +757,65 @@
 の仕様を見ること. また Cloneable の仕様にも一応目を通すと良いが, Cloneable
 は単なるマーカインタフェースであると言う驚愕の事実は知っておくべき.
 
-```
-   553		/**
-   554		 * この倍長整数の複製を返す.
-   555		 * <p>
-   556		 * 例として実装しているが, そもそもこの倍長整数オブジェクトは不変であるため, 複製の必要はない.
-   557		 *
-   558		 * @return 複製
-   559		 */
-   560		@Override
-   561		public LongLong clone() {
-   562			try {
-   563				return (LongLong) super.clone();
-   564			} catch (CloneNotSupportedException e) {
-   565				throw new InternalError();
-   566			}
-   567		}
+```java linenums:553
+	/**
+	 * この倍長整数の複製を返す.
+	 * <p>
+	 * 例として実装しているが, そもそもこの倍長整数オブジェクトは不変であるため, 複製の必要はない.
+	 *
+	 * @return 複製
+	 */
+	@Override
+	public LongLong clone() {
+		try {
+			return (LongLong) super.clone();
+		} catch (CloneNotSupportedException e) {
+			throw new InternalError();
+		}
+	}
 ```
 
 ## メソッド:equals.
 
-```
-   569		/**
-   570		 * この倍長整数と他のオブジェクトが等しいかどうかを示す.
-   571		 * <p>
-   572		 * 倍長整数が他のオブジェクトと等しいのは, 他のオブジェクトが倍長整数のインスタンスであり,
-   573		 * かつその下位ワードおよび上位ワードがそれぞれこの倍長整数の下位ワード,
-   574		 * 上位ワードと等しい場合に限る.
-   575		 *
-   576		 * @param o 比較対象の参照オブジェクト
-   577		 * @return この倍長整数が o 引数と等しい場合は {@code true}, それ以外の場合は {@code false}
-   578		 */
-   579		@Override
-   580		public boolean equals(Object o) {
-   581			boolean equality;
-   582			if (o instanceof LongLong) {
-   583				LongLong that = (LongLong) o;
-   584				equality = lo == that.lo && hi == that.hi;
-   585			} else {
-   586				equality = false;
-   587			}
-   588			return equality;
-   589		}
+```java linenums:569
+	/**
+	 * この倍長整数と他のオブジェクトが等しいかどうかを示す.
+	 * <p>
+	 * 倍長整数が他のオブジェクトと等しいのは, 他のオブジェクトが倍長整数のインスタンスであり,
+	 * かつその下位ワードおよび上位ワードがそれぞれこの倍長整数の下位ワード,
+	 * 上位ワードと等しい場合に限る.
+	 *
+	 * @param o 比較対象の参照オブジェクト
+	 * @return この倍長整数が o 引数と等しい場合は {@code true}, それ以外の場合は {@code false}
+	 */
+	@Override
+	public boolean equals(Object o) {
+		boolean equality;
+		if (o instanceof LongLong) {
+			LongLong that = (LongLong) o;
+			equality = lo == that.lo && hi == that.hi;
+		} else {
+			equality = false;
+		}
+		return equality;
+	}
 ```
 
 ## メソッド:hashCode.
 
-```
-   591		/**
-   592		 * この倍長整数のハッシュコード値を返す.
-   593		 *
-   594		 * @return この倍長整数のハッシュコード値
-   595		 */
-   596		@Override
-   597		public int hashCode() {
-   598			int code;
-   599			code = (int) lo ^ (int)(lo >>> 32);
-   600			code ^= (int) hi ^ (int)(hi >>> 32);
-   601			return code;
-   602		}
+```java linenums:591
+	/**
+	 * この倍長整数のハッシュコード値を返す.
+	 *
+	 * @return この倍長整数のハッシュコード値
+	 */
+	@Override
+	public int hashCode() {
+		int code;
+		code = (int) lo ^ (int)(lo >>> 32);
+		code ^= (int) hi ^ (int)(hi >>> 32);
+		return code;
+	}
 ```
 
 ## ゴミ.
@@ -825,36 +825,36 @@
 もうちょっとマシな除算のアルゴリズムを実装しようとしていたが, 間に合いそうにないので諦めた.
 いつか改良したいが, そもそも Java でこういう処理を書くのは苦痛以外の何ものでもない...
 
-```
-   604	//==== 実験的メソッド.
-   605	
-   606		public static long divModUnsigned(long num, int den) {
-   607			for (int k = 0; k < 32; ++k) {
-   608				boolean carry = num < 0;
-   609				num <<= 1;
-   610				if (carry || (num >>> 32) >= (den & 0xFFFFFFFFL)) {
-   611					num -= (long) den << 32;
-   612					++num;
-   613				}
-   614			}
-   615			return num;
-   616		}
-   617	
-   618		public Pair<LongLong, LongLong> divModUnsigned(LongLong numH, LongLong den) {
-   619			LongLong numL = this;
-   620			for (int k = 0; k < SIZE; ++k) {
-   621				boolean carry = numH.hi < 0;
-   622				numH = numH.shiftLeft(1);
-   623				if (numL.hi < 0)
-   624					numH = numH.increment();
-   625				numL = numL.shiftLeft(1);
-   626				if (carry || numH.compareUnsigned(den) >= 0) {
-   627					numH = numH.sub(den);
-   628					numL = numL.increment();
-   629				}
-   630			}
-   631			return Pair.of(numL, numH);
-   632		}
-   633	}
-```
-
+```java linenums:604
+//==== 実験的メソッド.
+
+	public static long divModUnsigned(long num, int den) {
+		for (int k = 0; k < 32; ++k) {
+			boolean carry = num < 0;
+			num <<= 1;
+			if (carry || (num >>> 32) >= (den & 0xFFFFFFFFL)) {
+				num -= (long) den << 32;
+				++num;
+			}
+		}
+		return num;
+	}
+
+	public Pair<LongLong, LongLong> divModUnsigned(LongLong numH, LongLong den) {
+		LongLong numL = this;
+		for (int k = 0; k < SIZE; ++k) {
+			boolean carry = numH.hi < 0;
+			numH = numH.shiftLeft(1);
+			if (numL.hi < 0)
+				numH = numH.increment();
+			numL = numL.shiftLeft(1);
+			if (carry || numH.compareUnsigned(den) >= 0) {
+				numH = numH.sub(den);
+				numL = numL.increment();
+			}
+		}
+		return Pair.of(numL, numH);
+	}
+}
+```
+

tt が 2015-11-09 10:12 に編集

--- Ver.3	2015-11-07 02:01:23+09:00
+++ Ver.4	2015-11-09 10:12:54+09:00
@@ -136,7 +136,7 @@
 
 日本語では「構築子」. メソッドとは区別される.
 名前をクラス名として, 戻り型を書かないとコンストラクタとなる.
-名前をクラスメイトしても, 戻り型を書いてしまえば一般のメソッドとなってしまうので,
+名前をクラス名としても, 戻り型を書いてしまえば一般のメソッドとなってしまうので,
 初心者は注意が必要. (今時は eclipse が警告を出すかも知れない.)
 
 この倍長整数オブジェクトは, 不変オブジェクトとして設計しているので, コンストラクタで初期化した

tt が 2015-11-07 02:01 に編集

--- Ver.2	2015-11-07 01:55:13+09:00
+++ Ver.3	2015-11-07 02:01:23+09:00
@@ -132,7 +132,9 @@
     43		}
 ```
 
-コンストラクタ. 日本語では「構築子」. メソッドとは区別される.
+## コンストラクタ.
+
+日本語では「構築子」. メソッドとは区別される.
 名前をクラス名として, 戻り型を書かないとコンストラクタとなる.
 名前をクラスメイトしても, 戻り型を書いてしまえば一般のメソッドとなってしまうので,
 初心者は注意が必要. (今時は eclipse が警告を出すかも知れない.)

tt が 2015-11-07 01:55 に編集

--- Ver.1	2015-11-07 01:46:15+09:00
+++ Ver.2	2015-11-07 01:55:13+09:00
@@ -152,7 +152,9 @@
     53		}
 ```
 
-## 非公開コンストラクタ. 非公開なので, クラス外からは利用できないコンストラクタである.
+## 非公開コンストラクタ.
+
+非公開なので, クラス外からは利用できないコンストラクタである.
 
 ```
     55		/**

tt が 2015-11-07 00:19 に投稿