Refactor README.

src/algorithms/graph/liu-hui-pi/README.md

@@ -1,9 +0,0 @@
-# Liu Hui's π Algorithm
-
-Multiply one side of a hexagon by the radius (of its circumcircle), then multiply this by three, to yield the area of a dodecagon; if we cut a hexagon into a dodecagon, multiply its side by its radius, then again multiply by six, we get the area of a 24-gon; the finer we cut, the smaller the loss with respect to the area of circle, thus with further cut after cut, the area of the resulting polygon will coincide and become one with the circle; there will be no loss
-
-
-
-## References
-
-- [Liu Hui's π Algorithm on Wikipedia](https://en.wikipedia.org/wiki/Liu_Hui's_%CF%80_algorithm)

src/algorithms/graph/liu-hui-pi/__test__/liu-hui-pi.test.js

@@ -1,16 +0,0 @@
-import pi from '../liu-hui-pi';
-
-describe('Liu Hui\'s π algorithm', () => {
-  it('Dodecagon π', () => {
-    expect(pi(1)).toBe(3);
-  });
-  it('24-gon π', () => {
-    expect(pi(2)).toBe(3.105828541230249);
-  });
-  it('6144-gon π', () => {
-    expect(pi(10)).toBe(3.1415921059992717);
-  });
-  it('201326592-gon π', () => {
-    expect(pi(25)).toBe(3.141592653589793);
-  });
-});

src/algorithms/math/liu-hui/README.md

@@ -0,0 +1,92 @@
+# Liu Hui's π Algorithm
+
+Liu Hui remarked in his commentary to The Nine Chapters on the Mathematical Art,
+that the ratio of the circumference of an inscribed hexagon to the diameter of 
+the circle was `three`, hence `π` must be greater than three. He went on to provide 
+a detailed step-by-step description of an iterative algorithm to calculate `π` to 
+any required accuracy based on bisecting polygons; he calculated `π` to 
+between `3.141024` and `3.142708` with a 96-gon; he suggested that `3.14` was 
+a good enough approximation, and expressed `π` as `157/50`; he admitted that 
+this number was a bit small. Later he invented an ingenious quick method to 
+improve on it, and obtained `π ≈ 3.1416` with only a 96-gon, with an accuracy 
+comparable to that from a 1536-gon. His most important contribution in this 
+area was his simple iterative `π` algorithm.
+
+## Area of a circle
+
+Liu Hui argued:
+
+> Multiply one side of a hexagon by the radius (of its 
+circumcircle), then multiply this by three, to yield the 
+area of a dodecagon; if we cut a hexagon into a 
+dodecagon, multiply its side by its radius, then again 
+multiply by six, we get the area of a 24-gon; the finer 
+we cut, the smaller the loss with respect to the area 
+of circle, thus with further cut after cut, the area of 
+the resulting polygon will coincide and become one with 
+the circle; there will be no loss
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/6/69/Cutcircle2.svg)
+
+Liu Hui's method of calculating the area of a circle.
+
+Further, Liu Hui proved that the area of a circle is half of its circumference 
+multiplied by its radius. He said:
+
+> Between a polygon and a circle, there is excess radius. Multiply the excess 
+radius by a side of the polygon. The resulting area exceeds the boundary of 
+the circle
+
+In the diagram `d = excess radius`. Multiplying `d` by one side results in 
+oblong `ABCD` which exceeds the boundary of the circle. If a side of the polygon 
+is small (i.e. there is a very large number of sides), then the excess radius 
+will be small, hence excess area will be small.
+
+> Multiply the side of a polygon by its radius, and the area doubles; 
+hence multiply half the circumference by the radius to yield the area of circle.
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/9/95/Cutcircle.svg)
+
+The area within a circle is equal to the radius multiplied by half the 
+circumference, or `A = r x C/2 = r x r x π`.
+
+## Iterative algorithm
+
+Liu Hui began with an inscribed hexagon. Let `M` be the length of one side `AB` of 
+hexagon, `r` is the radius of circle.
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/4/46/Liuhui_geyuanshu.svg)
+
+Bisect `AB` with line `OPC`, `AC` becomes one side of dodecagon (12-gon), let 
+its length be `m`. Let the length of `PC` be `j` and the length of `OP` be `G`.
+
+`AOP`, `APC` are two right angle triangles. Liu Hui used 
+the [Gou Gu](https://en.wikipedia.org/wiki/Pythagorean_theorem) (Pythagorean theorem)
+theorem repetitively:
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/dbfc192c78539c3901c7bad470302ededb76f813)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/ccd12a402367c2d6614c88e75006d50bfc3a9929)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/65d77869fc02c302d2d46d45f75ad7e79ae524fb)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/a7a0d0d7f505a0f434e5dd80c2fef6d2b30d6100)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/c31b9acf38f9d1a248d4023c3bf286bd03007f37)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/0dee798efb0b1e3e64d6b3542106cb3ecaa4a383)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/3ffeafe88d2983b364ad3442746063e3207fe842)
+
+
+From here, there is now a technique to determine `m` from `M`, which gives the 
+side length for a polygon with twice the number of edges. Starting with a 
+hexagon, Liu Hui could determine the side length of a dodecagon using this 
+formula. Then continue repetitively to determine the side length of a 
+24-gon given the side length of a dodecagon. He could do this recursively as 
+many times as necessary. Knowing how to determine the area of these polygons, 
+Liu Hui could then approximate `π`.
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Liu_Hui%27s_%CF%80_algorithm)

src/algorithms/math/liu-hui/__test__/liuHui.test.js

@@ -0,0 +1,19 @@
+import liuHui from '../liuHui';
+
+describe('liHui', () => {
+  it('Dodecagon π', () => {
+    expect(liuHui(1)).toBe(3);
+  });
+
+  it('24-gon π', () => {
+    expect(liuHui(2)).toBe(3.105828541230249);
+  });
+
+  it('6144-gon π', () => {
+    expect(liuHui(10)).toBe(3.1415921059992717);
+  });
+
+  it('201326592-gon π', () => {
+    expect(liuHui(25)).toBe(3.141592653589793);
+  });
+});

src/algorithms/math/liu-hui/liuHui.js

@@ -11,6 +11,7 @@ const getSideLength = (sideLength, count) => {
   // Liu Hui used the Gou Gu theorem repetitively.
   const g = Math.sqrt((r ** 2) - (m ** 2));
   const j = r - g;
+
   return getSideLength(Math.sqrt((j ** 2) + (m ** 2)), count - 1);
 };
 
@@ -27,27 +28,15 @@ const getSideCount = splitCount => c * (splitCount ? 2 ** splitCount : 1);
  * the smaller the loss with respect to the area of circle, thus with
  * further cut after cut, the area of the resulting polygon will coincide
  * and become one with the circle; there will be no loss
- * @param {Number} splitCount repeat times
- * @return {Number}
+ *
+ * @param {number} splitCount repeat times
+ * @return {number}
  */
-const pi = (splitCount = 1) => {
+export default function liuHui(splitCount = 1) {
   const sideLength = getSideLength(r, splitCount - 1);
   const sideCount = getSideCount(splitCount - 1);
   const p = sideLength * sideCount;
   const area = (p / 2) * r;
+
   return area / (r ** 2);
-};
-
-// !test
-// for (let i = 1; i < 26; i += 1) {
-//   const p = pi(i);
-//   console.log(
-//     'split count: %f, side count: %f, π: %f, is Math.PI? %o',
-//     i,
-//     getSideCount(i),
-//     p,
-//     p === Math.PI,
-//   );
-// }
-
-export default pi;
+}