/**
 * @name	CeL rational number function
 * @fileoverview
 * 本檔案包含了分數/有理數 (rational number)/比例值 (ratio) 的 functions，相當/類似於 BigRational, BigQuotient (numerator and denominator), BigDecimal。<br />
 * 在純 javascript 的環境下，藉由原生計算功能，盡可能提供高效的大數計算。<br />
 *
 * @example
 * <code>
 * CeL.run('data.math.rational');
 * </code>
 *
 * @since	2013/9/8 13:42:58
 * @see
 * https://en.wikipedia.org/wiki/Rational_number
 */


/*
TODO:
以 BigInt() 重寫。
http://reference.wolfram.com/mathematica/ref/RootApproximant.html

規格書:

rational = new Rational(numerator, denominator, base);

rational = new Rational(10783, 2775);
rational = new Rational('10783/2775');
rational = new Rational('3+2458/2775');
rational = new Rational('3 2458/2775');
//https://en.wikipedia.org/wiki/Vinculum_(symbol)
rational = new Rational('3.88¯576');
//Brackets
rational = new Rational('3.88(576)');

numerator 10783
denominator 2775

integer part 整數部分 == quotient == continued fraction[0]
fractional part 分數/小數部分 == remainder / denominator

mixed fraction 帶分數 == integer part + fractional part
vulgar fraction 真分數/假分數 == 

decimal approximation (numerical value) 無限小數 3.88576576576576576576576576
//https://en.wikipedia.org/wiki/Overline#Math_and_science
repeating decimal 循環小數 3.88¯576

continued fraction 連分數 == [3; 1, 7, 1, 3, 15, 1, 1, 2]

Egyptian fraction expansion 古埃及分數

最簡分數(irreducible fraction, reduced proper fraction)
約分 reduce

*/



'use strict';
if (typeof CeL === 'function')
	CeL.run(
	{
		name: 'data.math.rational',
		require: 'data.code.compatibility.|data.native.|data.math.integer.',
		no_extend: 'random,compare',
		code: function (library_namespace) {

			//	requiring
			var Integer = library_namespace.data.math.integer,
			// radix point / radix character / decimal mark
			radix_point = Integer.radix_point(),

			// 為正規 radix。
			valid_radix = Integer.valid_radix,
			DEFAULT_BASE = Integer.DEFAULT_BASE

			;

			// ---------------------------------------------------------------------//
			// basic constants. 定義基本常數。

			var

			// copy from data.math
			MULTIPLICATIVE_IDENTITY = library_namespace.MULTIPLICATIVE_IDENTITY,
			// copy from data.math
			ZERO_EXPONENT = library_namespace.ZERO_EXPONENT,

			// copy from data.math.integer.

			//{Integer}
			KEY_NUMERATOR = 'numerator',
			//{Integer|Undefined}integer > 0
			KEY_DENOMINATOR = 'denominator',
			//{Boolean|Undefined}最簡分數
			KEY_IRREDUCIBLE = 'irreducible',

			// 應與 parseInt() 一致。
			DEFAULT_RADIX = parseInt('10'),

			// 可辨認之數字字串。
			//	[ full , sign, integer part 整數部分, sign of fractional part 小數部分, numerator, denominator ]
			PATTERN_FRACTION = /([+\-]?)(?:(\d+)([ +\-]))?(\d+)\/(\d+)/,
			//	[ full , sign, integer part 整數部分, fractional part 小數部分, repeating decimal 循環小數1, repeating decimal 循環小數2 ]
			PATTERN_DECIMAL = /([+\-]?)(\d*)\.(\d*)(?:¯(\d+)|\((\d+)\))?/

			;

			// ---------------------------------------------------------------------//
			// 初始調整並規範基本常數。


			// ---------------------------------------------------------------------//
			// 工具函數

			function do_modified(rational, not_amount) {
				if (!not_amount)
					delete rational[KEY_IRREDUCIBLE];
			}


			// ---------------------------------------------------------------------//
			//	definition of module integer

			/**
			 * 任意大小、帶正負號的有理數。rational number instance.
			 *
			 * @example
			 * <code>
			 * </code>
			 *
			 * @class	Rational 的 constructor
			 * @constructor
			 */
			function Rational(number) {
				if (!(this instanceof Rational))
					return 1 === arguments.length && is_Rational(number) ? number : assignment.apply(new Rational, arguments);
				if (arguments.length > 0)
					assignment.apply(this, arguments);
			}

			//	instance public interface	-------------------

			// https://en.wikipedia.org/wiki/Operation_(mathematics)
			var OP_REFERENCE = {
				'+': add,
				'-': subtract,
				'*': multiply,
				'/': divide,
				'^': power,
				'=': assignment,
				'==': compare
			};

			Object.assign(Rational.prototype, OP_REFERENCE, {
				reduce: reduce,
				// 下面全部皆為 assignment，例如 '+' 實為 '+='。
				assignment: assignment,

				// add_assignment
				add: add,
				// subtract_assignment
				subtract: subtract,
				// multiply_assignment
				multiply: multiply,
				// divide_assignment
				divide: divide,
				div: divide,

				power: power,
				pow: power,
				square: square,
				square_root: square_root,
				sqrt: square_root,
				// 至此為 assignment。

				clone: clone,

				//https://en.wikipedia.org/wiki/Absolute_value
				abs: function (negative) {
					do_modified(this, true);
					this[KEY_NUMERATOR].abs(negative);
					return this;
				},
				// 變換正負號。
				negate: function () {
					do_modified(this, true);
					this[KEY_NUMERATOR].negate();
					return this;
				},
				is_positive: function () {
					return this.compare(0) > 0;
				},
				is_negative: function () {
					return this[KEY_NUMERATOR].is_negative();
				},
				// 正負符號。
				// https://en.wikipedia.org/wiki/Sign_(mathematics)
				// https://en.wikipedia.org/wiki/Sign_function
				sign: function (negative) {
					return this[KEY_NUMERATOR].sign(negative);
				},

				to_continued_fraction: to_continued_fraction,
				to_repeating_decimal: to_repeating_decimal,
				integer_part: function () {
					var n = this[KEY_NUMERATOR].clone().expand_exponent();
					if (KEY_DENOMINATOR in this)
						n.divide(this[KEY_DENOMINATOR]);
					return n;
				},
				toPrecision: toPrecision,

				factorize: factorize,
				log: log,

				is_0: function (little_natural) {
					return this[KEY_NUMERATOR].is_0(little_natural);
				},
				isFinite: function () {
					return this[KEY_NUMERATOR].isFinite();
				},
				//compare_amount: compare_amount,
				compare: compare,
				equals: function (number) {
					return this.compare(number) === 0;
				},
				// is proper fraction
				is_proper: function () {
					return (KEY_DENOMINATOR in this) && this[KEY_NUMERATOR].compare(this[KEY_DENOMINATOR]) < 0;
				},

				op: Integer.set_operate(OP_REFERENCE),
				valueOf: valueOf,
				toString: toString
			});

			//	class public interface	---------------------------
			function is_Rational(value) {
				return value instanceof Rational;
			}

			function Rational_compare(number1, number2) {
				if (typeof number1 === 'number' && typeof number2 === 'number')
					return number1 - number2;

				if (!is_Rational(number1))
					number1 = new Rational(number1);
				return number1.compare(number2);
			}

			//get the extreme value (極端值: max/min) of input values
			function extreme(values, get_minima) {
				var index = values.length, extreme_value, value, compare;
				if (!index)
					// ES6: Math.max: If no arguments are given, the result is −∞.
					return get_minima ? Infinity : -Infinity;

				extreme_value = values[--index];
				while (0 < index--) {
					// WARNING 注意: 當碰上許多大數時，會出現需要多次轉換 extreme_value 成 Rational 的效能低下情形!
					//但若許多數字不同底，而最大的是 String，則可能獲得部分效能。
					if (Number.isNaN(compare = Rational_compare(extreme_value, value = values[index])))
						// ES6: Math.max: If any value is NaN, the result is NaN.
						return NaN;

					if (get_minima ? compare > 0 : compare < 0)
						extreme_value = value;

					//依規範，必須掃描一次，確定沒 NaN。不可中途跳出。
					if (false && (get_minima ? compare > 0 : compare < 0)
						//當有改變時才偵測。
						&& typeof (extreme_value = value) === 'number' && !Number.isFinite(extreme_value = value))
						break;
				}
				return extreme_value;
			}

			// TODO: max
			function random(max) {
				return new Rational(Integer.random(), Integer.random());
			}

			function is_0(value, little_natural) {
				if (typeof value === 'string')
					value = new Rational(value);
				return value === (little_natural || 0) || (is_Rational(value) ? value[KEY_NUMERATOR] : Integer(value)).is_0(little_natural);
			}

			Object.assign(Rational, {
				from_continued_fraction: function (sequence, length, base) {
					var convergent = Integer.convergent_of(sequence, length, base);
					return new Rational(convergent[0], convergent[1]);
				},

				random: random,
				max: function Rational_max() {
					// get max()
					return extreme(arguments);
				},
				min: function Rational_min() {
					// get min()
					return extreme(arguments, true);
				},
				compare: Rational_compare,
				// little_natural: little natural number, e.g., 1
				is_0: is_0,

				is_Rational: is_Rational
			});


			// ---------------------------------------------------------------------//

			// 因 clone 頗為常用，作特殊處置以增進效率。
			function clone() {
				var rational = new Rational;
				rational[KEY_NUMERATOR] = this[KEY_NUMERATOR].clone();
				if (KEY_DENOMINATOR in this)
					rational[KEY_DENOMINATOR] = this[KEY_DENOMINATOR].clone();
				if (KEY_IRREDUCIBLE in this)
					rational[KEY_IRREDUCIBLE] = this[KEY_IRREDUCIBLE];
				return rational;
			}

			function assignment(numerator, denominator, base) {
				do_modified(this);

				var matched, tmp;
				if (is_Rational(numerator)) {
					[KEY_DENOMINATOR, KEY_IRREDUCIBLE].forEach(function (key) {
						if (key in numerator)
							this[key] = numerator[key];
						else
							delete this[key];
					}, this);
					this[KEY_NUMERATOR] = numerator = numerator[KEY_NUMERATOR];

				} else if (typeof numerator === 'string' && (matched = numerator.match(PATTERN_FRACTION))) {
					//rational = new Rational('10783/2775');
					//rational = new Rational('3+2458/2775');
					//rational = new Rational('3 2458/2775');

					if (base === undefined && valid_radix(denominator))
						// shift arguments
						base = denominator, denominator = undefined;

					if (!valid_radix(base))
						base = DEFAULT_RADIX;

					//	[ full , sign, integer part 整數部分, sign of fractional part 小數部分, numerator, denominator ]
					if (matched[3] === '-' && matched[1] !== '-')
						library_namespace.error('assignment: Invalid number sign!');

					this[KEY_DENOMINATOR] = tmp = new Integer(matched[5], base, DEFAULT_BASE);
					this[KEY_NUMERATOR] = numerator = new Integer(matched[4], base, DEFAULT_BASE);
					if (matched[2])
						numerator.add((new Integer(matched[2], base, DEFAULT_BASE)).multiply(tmp));
					if (matched[1] === '-')
						// 將正負符號擺在 [KEY_NUMERATOR]，確保 [KEY_DENOMINATOR] 不為負。
						numerator.negate();

				} else if (typeof numerator === 'string' && (matched = numerator.match(PATTERN_DECIMAL))) {
					//https://en.wikipedia.org/wiki/Vinculum_(symbol)
					//rational = new Rational('3.88¯576');
					//Brackets
					//rational = new Rational('3.88(576)');

					if (base === undefined && valid_radix(denominator))
						// shift arguments
						base = denominator, denominator = undefined;

					if (!valid_radix(base))
						base = DEFAULT_RADIX;

					//	[ full , sign, integer part 整數部分, fractional part 小數部分, repeating decimal 循環小數1, repeating decimal 循環小數2 ]
					// e.g., 1111.222¯33333 → 1111 + (22233333 - 222) / 99999000

					// 處理完小數部分之 numerator。
					if (matched[4] || (matched[4] = matched[5])) {
						// 有循環節(period)。
						numerator = new Integer(matched[3] + matched[4], base, DEFAULT_BASE);
						if (matched[3])
							numerator.add(new Integer(matched[3], base, DEFAULT_BASE), true);
						tmp = (base - 1).toString(base).repeat(matched[4].length);
					} else {
						// 無循環節(period)。
						numerator = new Integer(matched[3] || 0, base, DEFAULT_BASE);
						tmp = MULTIPLICATIVE_IDENTITY;
					}

					if (matched[3])
						tmp += '0'.repeat(matched[3].length);
					if (tmp === MULTIPLICATIVE_IDENTITY)
						delete this[KEY_DENOMINATOR];
					else
						// assert: {String} tmp
						this[KEY_DENOMINATOR] = new Integer(tmp, base, DEFAULT_BASE);

					if (matched[2])
						numerator.add(new Integer(matched[2], base, DEFAULT_BASE).multiply(this[KEY_DENOMINATOR]));

					if (matched[1] === '-')
						// 將正負符號擺在 [KEY_NUMERATOR]，確保 [KEY_DENOMINATOR] 不為負。
						numerator.negate();
					this[KEY_NUMERATOR] = numerator;

				} else {
					delete this[KEY_DENOMINATOR];
					if ((this[KEY_NUMERATOR] = numerator = new Integer(tmp = numerator, base, DEFAULT_BASE)).isNaN())
						library_namespace.error('assignment: Invalid number: [' + tmp + '].');

						// 確保不使用 exponent，使 exponent 為 0。
					else if ((tmp = numerator.get_exponent()) > 0)
						numerator.expand_exponent();
					else if (tmp < 0) {
						(this[KEY_DENOMINATOR] = new Integer(numerator.get_base(), numerator.get_base()))
							.power(-tmp);
						numerator.get_exponent(0);
					}
				}

				if (denominator)
					// rational = new Rational(10783, 2775);
					this.divide(valid_radix(base) && typeof denominator === 'string' ? new Rational(denominator, MULTIPLICATIVE_IDENTITY, base) : denominator);

				if ((KEY_DENOMINATOR in this)
					&& (!numerator.isFinite()
					|| numerator.is_0()
					// [KEY_DENOMINATOR] 預設即為 MULTIPLICATIVE_IDENTITY。
					|| this[KEY_DENOMINATOR].is_0(MULTIPLICATIVE_IDENTITY)
					))
					delete this[KEY_DENOMINATOR];

				return this;
			}

			function reduce() {
				if ((KEY_DENOMINATOR in this) && !this[KEY_IRREDUCIBLE]) {
					var gcd = this[KEY_NUMERATOR].clone().Euclidean_algorithm(this[KEY_DENOMINATOR].clone())[1];
					this[KEY_NUMERATOR].divide(gcd);
					if (this[KEY_DENOMINATOR].equals(gcd))
						delete this[KEY_DENOMINATOR];
					else
						this[KEY_DENOMINATOR].divide(gcd);
					this[KEY_IRREDUCIBLE] = true;
				}

				return this;
			}

			/**
			 * 測試大小/比大小
			 * @param number	the number to compare
			 * @return	{Number}	0:==, <0:<, >0:>
			 * @_name	_module_.prototype.compare_to
			 */
			function compare(number) {
				if (typeof number === 'string')
					number = new Rational(number);
				if (is_Rational(number) && (KEY_DENOMINATOR in number.reduce()))
					return this.reduce()[KEY_NUMERATOR].clone().multiply(number[KEY_DENOMINATOR])
					//
					.compare(KEY_DENOMINATOR in this ? this[KEY_DENOMINATOR].clone().multiply(number[KEY_NUMERATOR]) : number[KEY_NUMERATOR]);

				else {
					if (is_Rational(number))
						number = number[KEY_NUMERATOR];
					return this.reduce()[KEY_NUMERATOR]
					//
					.compare(KEY_DENOMINATOR in this ? this[KEY_DENOMINATOR].clone().multiply(number) : number);
				}
			}


			// ---------------------------------------------------------------------//
			//四則運算，即加減乘除， + - * / (+-×÷)**[=]
			//https://en.wikipedia.org/wiki/Elementary_arithmetic

			// 正規化(normalize) operand
			// return is_Integer
			function normalize_operand(operand, rational) {
				// TODO: defferent base
				return Integer.is_Integer(operand) && operand.get_base() === rational[KEY_NUMERATOR].get_base()
					|| is_Rational(operand) && operand[KEY_NUMERATOR].get_base() === rational[KEY_NUMERATOR].get_base()
					? operand
					: new Rational(operand);
			}

			// Addition 和: addend + addend = sum
			function add(addend, is_subtract) {
				if (!is_0(addend = normalize_operand(addend, this))) {
					//	assert: addend != 0.

					do_modified(this.reduce());

					addend = Rational(addend);

					if (is_Rational(addend) && !(KEY_DENOMINATOR in addend.reduce()))
						addend = addend[KEY_NUMERATOR];
					// assert: addend is non-Rational or reduced Rational with denominator.

					if (is_Rational(addend)
						// 分母相同時，直接相加減分子。
					 ? (KEY_DENOMINATOR in this) && addend[KEY_DENOMINATOR].equals(this[KEY_DENOMINATOR])
						// 分母相同(=1)時，直接相加減分子。
					 : !(KEY_DENOMINATOR in this))
						this[KEY_NUMERATOR].add(is_Rational(addend) ? addend[KEY_DENOMINATOR] : addend, is_subtract);
						// 分母相同，毋須更動。

					else {
						// n1/d1 ± n2/d2 = (n1d2 ± n2d1)/d1d2
						// assert: d1 != d2
						var denominator_need_multiply;
						if (is_Rational(addend)) {
							// 僅在 (KEY_DENOMINATOR in addend) 時，才須處理分母。
							if (KEY_DENOMINATOR in this)
								//為不干擾 this[KEY_NUMERATOR].add() 之操作，另作 cache。
								denominator_need_multiply = addend[KEY_DENOMINATOR];
							else
								// 為不干擾 addend，另外創建。
								this[KEY_DENOMINATOR] = addend[KEY_DENOMINATOR].clone();
							this[KEY_NUMERATOR].multiply(addend[KEY_DENOMINATOR]);
							addend = addend[KEY_NUMERATOR];
						}
						this[KEY_NUMERATOR].add(KEY_DENOMINATOR in this ? this[KEY_DENOMINATOR].clone().multiply(addend) : addend, is_subtract);
						if (denominator_need_multiply)
							this[KEY_DENOMINATOR].multiply(denominator_need_multiply);
					}
				}

				return this;
			}

			// Subtraction 差: minuend − subtrahend = difference
			function subtract(subtrahend) {
				return this.add(subtrahend, true);
			}

			// Multiplication 乘: multiplicand × multiplier = product
			function multiply(multiplier) {
				if (!this[KEY_NUMERATOR].isNaN())
					if (is_0(multiplier = normalize_operand(multiplier, this))) {
						do_modified(this);
						this[KEY_NUMERATOR].assignment(this[KEY_NUMERATOR].isFinite() ? 0 : NaN);
						delete this[KEY_DENOMINATOR];

					} else if (!is_0(multiplier, MULTIPLICATIVE_IDENTITY)) {
						do_modified(this.reduce());

						if (is_Rational(multiplier) && !(KEY_DENOMINATOR in multiplier.reduce()))
							multiplier = multiplier[KEY_NUMERATOR];
						// assert: multiplier is non-Rational or reduced Rational with denominator.

						if (is_Rational(multiplier)) {
							this[KEY_NUMERATOR].multiply(multiplier[KEY_NUMERATOR]);
							if (KEY_DENOMINATOR in this)
								this[KEY_DENOMINATOR].multiply(multiplier[KEY_DENOMINATOR]);
							else
								this[KEY_DENOMINATOR] = multiplier[KEY_DENOMINATOR].clone();
						} else
							this[KEY_NUMERATOR].multiply(multiplier);
					}

				return this;
			}

			// Division 除: dividend ÷ divisor = quotient
			function divide(denominator) {
				if (!this[KEY_NUMERATOR].isNaN())
					if (!denominator || is_0(denominator = normalize_operand(denominator, this))) {
						do_modified(this);
						this[KEY_NUMERATOR].assignment(1 / 0);
						delete this[KEY_DENOMINATOR];

					} else if (!is_0(denominator, MULTIPLICATIVE_IDENTITY)) {
						do_modified(this.reduce());

						if (is_Rational(denominator)) {
							if (KEY_DENOMINATOR in denominator.reduce())
								this[KEY_NUMERATOR].multiply(denominator[KEY_DENOMINATOR]);
							denominator = denominator[KEY_NUMERATOR];
						}

						if (KEY_DENOMINATOR in this)
							this[KEY_DENOMINATOR].multiply(denominator);
						else
							this[KEY_DENOMINATOR] = denominator.clone();
					}

				return this;
			}


			// ---------------------------------------------------------------------//

			// https://en.wikipedia.org/wiki/Minimal_polynomial_(field_theory)
			// return p[{Integer}], p[0] + p[1]*this = 0
			function minimal_polynomial() {
				this.reduce();
				var polynomial = [this[KEY_NUMERATOR], this[KEY_DENOMINATOR]];
				// translate to {Number} if possible.
				polynomial.forEach(function (coefficient, index) {
					var value = coefficient.valueOf();
					polynomial[index] = Number.isSafeInteger(value) ? value : coefficient.clone();
				});
				return polynomial;
			}

			function continued_fraction_toString() {
				return '[' + this.join(',').replace(/,/, ';') + ']';
			}

			function to_continued_fraction() {
				var c = KEY_DENOMINATOR in this
				// http://www.mathpath.org/concepts/cont.frac.htm
				? this[KEY_NUMERATOR].clone().Euclidean_algorithm(this[KEY_DENOMINATOR].clone())[0]
				//
				: [this[KEY_NUMERATOR].clone()];
				Object.defineProperty(c, 'toString', {
					enumerable: false,
					value: continued_fraction_toString
				});
				return c;
			}

			// precise divide, to repeating decimal
			// radix===1: get {Integer} object instead of {String}
			// return [ integer part, non-repeating fractional part, period (repeating decimal part) ]
			// https://en.wikipedia.org/wiki/Repeating_decimal
			function to_repeating_decimal(radix, period_limit) {
				return this[KEY_NUMERATOR].precise_divide(this[KEY_DENOMINATOR] || MULTIPLICATIVE_IDENTITY, radix, period_limit);
			}

			// precision: 不包含小數點，共取 precision 位，precision > 0。
			function toPrecision(precision) {
				if (!(0 < precision) || !Number.isSafeInteger(precision |= 0))
					return this.toString();

				var d, tmp, is_negative = this[KEY_NUMERATOR].is_negative();
				if (precision < 1e2
					// 當循環節(period)相對於 precision 過長，採用 .to_repeating_decimal() 無實益。
					|| ((KEY_DENOMINATOR in this) && precision < 4 * this[KEY_DENOMINATOR].valueOf())
					|| !(d = this.to_repeating_decimal(DEFAULT_RADIX, precision))) {
					//general method
					d = new Integer(this[KEY_NUMERATOR], DEFAULT_RADIX);
					if (KEY_DENOMINATOR in this)
						d.divide(tmp = new Integer(this[KEY_DENOMINATOR], DEFAULT_RADIX),
							precision + tmp.length + Math.max(tmp.get_exponent(), 0));
					d = d.toString();
					d = d.match(/(-?\d*)\.(\d+)/) || d.match(/(-?\d*)/);
					d = [d[1], d[2] || '', ''];
				}

				// assert: d = [ {String}integer part, {String}non-repeating fractional part, {String}period (repeating decimal part) ]

				if (d[0].length === precision + (is_negative ? 1 : 0) && d[0].charAt(d[0].length - 1) !== '0')
					return d[0];

				if (is_negative)
					//減少負擔。
					d[0] = d[0].slice(1);

				if (d[0] === '0') {
					precision++;
					if (tmp = d[1].match(/^0+/))
						precision += tmp[0].length;
				}

				if (d[0].length < precision) {
					// 會用到小數部分。
					d[0] += radix_point + d[1];
					// -2: radix_point, 判斷用之位數1位
					if (d[0].length - 2 < precision) {
						if (!d[2])
							d[2] = '0';
						d[0] += d[2].repeat(Math.ceil((precision - d[0].length + 2) / d[2].length));
					}
					// 34.56  3
					d = (5 <= (d[0].charAt(precision + 1) | 0)
						? d[0].slice(0, precision) + ((d[0].charAt(precision) | 0) + 1)
						: d[0].slice(0, precision + 1));

				} else
					d = d[0].charAt(0) + radix_point
						+ (5 <= (d[0].charAt(precision) | 0)
						? d[0].slice(1, --precision) + ((d[0].charAt(precision) | 0) + 1)
						: d[0].slice(1, precision))
						+ 'e+' + (d[0].length - 1);


				return is_negative ? '-' + d : d;
			}

			// ---------------------------------------------------------------------//
			// advanced functions

			function factorize(radix, limit) {
				var f, d, factors = this.reduce()[KEY_NUMERATOR].factorize(radix, limit);

				if (KEY_DENOMINATOR in this) {
					d = this[KEY_DENOMINATOR].factorize(radix, limit);
					// TODO: sort
					for (f in d)
						factors[f] = -d[f];
				}

				return factors;
			}

			function square() {
				do_modified(this.reduce());

				this[KEY_NUMERATOR].square();

				if (KEY_DENOMINATOR in this)
					this[KEY_DENOMINATOR].square();

				return this;
			}

			// Exponentiation 冪/乘方: base ^ exponent = power
			// https://en.wikipedia.org/wiki/Exponentiation
			// https://en.wikipedia.org/wiki/Exponentiation_by_squaring
			function power(exponent) {
				do_modified(this.reduce());

				this[KEY_NUMERATOR].power(exponent);

				if (KEY_DENOMINATOR in this)
					this[KEY_DENOMINATOR].power(exponent);

				return this;
			}

			// WARNING 注意: this will get floor(sqrt(this))，結果僅會回傳整數！
			function square_root(precision) {
				do_modified(this.reduce());

				if (KEY_DENOMINATOR in this) {
					this[KEY_NUMERATOR].divide(this[KEY_DENOMINATOR], precision);
					delete this[KEY_DENOMINATOR];
				}

				this[KEY_NUMERATOR].square_root(precision);

				return this;
			}

			function log(base) {
				var value = this[KEY_NUMERATOR].log(base);

				if (KEY_DENOMINATOR in this)
					value -= this[KEY_DENOMINATOR].log(base);

				return value;
			}


			// ---------------------------------------------------------------------//

			// WARNING 注意: 若回傳非 Number.isSafeInteger()，則會有誤差，不能等於最佳近似值。
			function valueOf(type) {
				var n = this[KEY_NUMERATOR].valueOf(), d;
				if (KEY_DENOMINATOR in this)
					if (isFinite(d = this[KEY_DENOMINATOR].valueOf()) || isFinite(n))
						n /= d;
					else
						n = this[KEY_NUMERATOR].ratio_to(this[KEY_DENOMINATOR]);
				return n;
			}

			// default: numerator/denominator
			// e.g., 1 2/3
			var TYPE_MIX = 1,
			// e.g., 1.2¯3
			TYPE_DECIMAL = 2,
			// Parentheses, e.g., 1.2(3)
			TYPE_PARENTHESES = 3;
			function toString(type) {
				if (!(KEY_DENOMINATOR in this))
					return this[KEY_NUMERATOR].toString();

				var string = this[KEY_NUMERATOR];
				if (type === TYPE_DECIMAL || type === TYPE_PARENTHESES) {
					string = string.precise_divide(this[KEY_DENOMINATOR]);
					if (string[2]) {
						string[1] += type === TYPE_DECIMAL
						// e.g., 1.2¯3
						? '¯' + string[2]
						// Parentheses, e.g., 1.2(3)
						: '(' + string[2] + ')';
						// using the combining overline (U+0305)
						// https://en.wikipedia.org/wiki/Vinculum_(symbol)#Computer_entry_of_the_symbol
						// https://en.wikipedia.org/wiki/Overline
						//string[1] += string[2].replace(/(.)/g, '$1̅');
					}
					if (string[1])
						string[0] += radix_point + string[1];
					return string[0];
				}

				return (type === TYPE_MIX ? (string = string.clone()).division(this[KEY_DENOMINATOR]).toString() + ' ' + string.abs().toString() : string.toString())
				//
				+ '/' + this[KEY_DENOMINATOR].toString();
			}


			// ---------------------------------------------------------------------//

			return Rational;
		}

	});