Home Reference Source

src/math/core/Complex.js

  1. /**
  2.  * The script is part of konpeito.
  3.  * 
  4.  * AUTHOR:
  5.  *  natade (http://twitter.com/natadea)
  6.  * 
  7.  * LICENSE:
  8.  *  The MIT license https://opensource.org/licenses/MIT
  9.  */
  10.  
  11. import Polyfill from "../tools/Polyfill.js";
  12. import Probability from "./tools/Probability.js";
  13. import Random from "./tools/Random.js";
  14. import Matrix from "./Matrix.js";
  15. import BigInteger from "./BigInteger.js";
  16. import BigDecimal from "./BigDecimal.js";
  17. import Fraction from "./Fraction.js";
  18. import MathContext from "./context/MathContext.js";
  19. import KonpeitoFloat from "./base/KonpeitoFloat.js";
  20.  
  21. /**
  22.  * Complex type argument.
  23.  * - Complex
  24.  * - number
  25.  * - boolean
  26.  * - string
  27.  * - Array<number>
  28.  * - {_re:number,_im:number}
  29.  * - {doubleValue:number}
  30.  * - {toString:function}
  31.  * 
  32.  * Initialization can be performed as follows.
  33.  * - 1200, "1200", "12e2", "1.2e3"
  34.  * - "3 + 4i", "4j + 3", [3, 4].
  35.  * @typedef {Complex|number|boolean|string|Array<number>|{_re:number,_im:number}|{doubleValue:number}|{toString:function}} KComplexInputData
  36.  */
  37.  
  38. /**
  39.  * Random number generation class used within Complex.
  40.  * @type {Random}
  41.  * @ignore
  42.  */
  43. const random_class = new Random();
  44.  
  45. /**
  46.  * Collection of functions used in Complex.
  47.  * @ignore
  48.  */
  49. class ComplexTool {
  50.  
  51. 	/**
  52. 	 * Create data for complex numbers from strings.
  53. 	 * @param {string} text - Target strings.
  54. 	 * @returns {{real : number, imag : number}}
  55. 	 */
  56. 	static ToComplexFromString(text) {
  57. 		let str = text.replace(/\s/g, "").toLowerCase();
  58. 		str = str.replace(/infinity|inf/g, "1e100000");
  59. 		// 複素数の宣言がない場合
  60. 		if(!(/[ij]/.test(str))) {
  61. 			return {
  62. 				real : parseFloat(str),
  63. 				imag : 0.0
  64. 			};
  65. 		}
  66. 		// この時点で複素数である。
  67. 		// 以下真面目に調査
  68. 		let re = 0;
  69. 		let im = 0;
  70. 		let buff;
  71. 		// 最後が$なら右側が実数、最後が[+-]なら左側が実数
  72. 		buff = str.match(/[+-]?(([0-9]+(\.[0-9]+)?(e[+-]?[0-9]+)?)|(nan))($|[+-])/);
  73. 		if(buff) {
  74. 			re = parseFloat(buff[0]);
  75. 		}
  76. 		// 複素数は数値が省略される場合がある
  77. 		buff = str.match(/[+-]?(([0-9]+(\.[0-9]+)?(e[+-]?[0-9]+)?)|(nan))?[ij]/);
  78. 		if(buff) {
  79. 			buff = buff[0].substring(0, buff[0].length - 1);
  80. 			// i, +i, -j のように実数部がなく、数値もない場合
  81. 			if((/^[-+]$/.test(buff)) || buff.length === 0) {
  82. 				im = buff === "-" ? -1 : 1;
  83. 			}
  84. 			else {
  85. 				im = parseFloat(buff);
  86. 			}
  87. 		}
  88. 		return {
  89. 			real : re,
  90. 			imag : im
  91. 		};
  92. 	}
  93.  
  94. }
  95.  
  96. /**
  97.  * Complex number class. (immutable)
  98.  */
  99. export default class Complex extends KonpeitoFloat {
  100.  
  101. 	/**
  102. 	 * Create a complex number.
  103. 	 * 
  104. 	 * Initialization can be performed as follows.
  105. 	 * - 1200, "1200", "12e2", "1.2e3"
  106. 	 * - "3 + 4i", "4j + 3", [3, 4].
  107. 	 * @param {KComplexInputData} number - Complex number. See how to use the function.
  108. 	 */
  109. 	constructor(number) {
  110. 		super();
  111. 		
  112. 		// 行列で使うためイミュータブルは必ず守ること。
  113. 		if(arguments.length === 1) {
  114. 			const obj = number;
  115. 			if(obj instanceof Complex) {
  116. 				
  117. 				/**
  118. 				 * The real part of this Comlex.
  119. 				 * @private
  120. 				 * @type {number}
  121. 				 */
  122. 				this._re = obj._re;
  123. 				
  124. 				/**
  125. 				 * The imaginary part of this Comlex.
  126. 				 * @private
  127. 				 * @type {number}
  128. 				 */
  129. 				this._im = obj._im;
  130. 			}
  131. 			else if(typeof obj === "number") {
  132. 				this._re = obj;
  133. 				this._im = 0.0;
  134. 			}
  135. 			else if(typeof obj === "string") {
  136. 				const x = ComplexTool.ToComplexFromString(obj);
  137. 				this._re = x.real;
  138. 				this._im = x.imag;
  139. 			}
  140. 			else if(obj instanceof Array) {
  141. 				if(obj.length === 2) {
  142. 					this._re = obj[0];
  143. 					this._im = obj[1];
  144. 				}
  145. 				else {
  146. 					throw "Complex Unsupported argument " + arguments;
  147. 				}
  148. 			}
  149. 			else if(typeof obj === "boolean") {
  150. 				this._re = obj ? 1 : 0;
  151. 				this._im = 0.0;
  152. 			}
  153. 			else if("doubleValue" in obj) {
  154. 				this._re = obj.doubleValue;
  155. 				this._im = 0.0;
  156. 			}
  157. 			else if(("_re" in obj) && ("_im" in obj)) {
  158. 				this._re = obj._re;
  159. 				this._im = obj._im;
  160. 			}
  161. 			else if(obj instanceof Object) {
  162. 				const x = ComplexTool.ToComplexFromString(obj.toString());
  163. 				this._re = x.real;
  164. 				this._im = x.imag;
  165. 			}
  166. 			else {
  167. 				throw "Complex Unsupported argument " + arguments;
  168. 			}
  169. 		}
  170. 		else {
  171. 			throw "Complex Many arguments : " + arguments.length;
  172. 		}
  173. 	}
  174.  
  175. 	/**
  176. 	 * Create an entity object of this class.
  177. 	 * @param {KComplexInputData} number
  178. 	 * @returns {Complex}
  179. 	 */
  180. 	static create(number) {
  181. 		if(number instanceof Complex) {
  182. 			return number;
  183. 		}
  184. 		else {
  185. 			return new Complex(number);
  186. 		}
  187. 	}
  188. 	
  189. 	/**
  190. 	 * Convert number to Complex type.
  191. 	 * @param {KComplexInputData} number
  192. 	 * @returns {Complex}
  193. 	 */
  194. 	static valueOf(number) {
  195. 		return Complex.create(number);
  196. 	}
  197. 	
  198. 	/**
  199. 	 * Convert to Complex.
  200. 	 * If type conversion is unnecessary, return the value as it is.
  201. 	 * @param {KComplexInputData} number 
  202. 	 * @returns {Complex}
  203. 	 * @ignore
  204. 	 */
  205. 	static _toComplex(number) {
  206. 		if(number instanceof Complex) {
  207. 			return number;
  208. 		}
  209. 		else if(number instanceof Matrix) {
  210. 			return Matrix._toComplex(number);
  211. 		}
  212. 		else {
  213. 			return new Complex(number);
  214. 		}
  215. 	}
  216.  
  217. 	/**
  218. 	 * Convert to real number.
  219. 	 * @param {KComplexInputData} number 
  220. 	 * @returns {number}
  221. 	 * @ignore
  222. 	 */
  223. 	static _toDouble(number) {
  224. 		if(typeof number === "number") {
  225. 			return number;
  226. 		}
  227. 		const complex_number = Complex._toComplex(number);
  228. 		if(complex_number.isReal()) {
  229. 			return complex_number.real;
  230. 		}
  231. 		else {
  232. 			throw "not support complex numbers.[" + number + "]";
  233. 		}
  234. 	}
  235.  
  236. 	/**
  237. 	 * Convert to integer.
  238. 	 * @param {KComplexInputData} number 
  239. 	 * @returns {number}
  240. 	 * @ignore
  241. 	 */
  242. 	static _toInteger(number) {
  243. 		return Math.trunc(Complex._toDouble(number));
  244. 	}
  245.  
  246. 	/**
  247. 	 * Deep copy.
  248. 	 * @returns {Complex} 
  249. 	 */
  250. 	clone() {
  251. 		return this;
  252. 	}
  253.  
  254. 	/**
  255. 	 * Convert to string.
  256. 	 * @returns {string} 
  257. 	 */
  258. 	toString() {
  259. 		/**
  260. 		 * @type {function(number): string }
  261. 		 */
  262. 		const formatG = function(x) {
  263. 			let numstr = x.toPrecision(6);
  264. 			if(numstr.indexOf(".") !== -1) {
  265. 				numstr = numstr.replace(/\.?0+$/, "");  // 1.00 , 1.10
  266. 				numstr = numstr.replace(/\.?0+e/, "e"); // 1.0e , 1.10e
  267. 			}
  268. 			else if(/inf/i.test(numstr)) {
  269. 				if(x === Number.POSITIVE_INFINITY) {
  270. 					return "Inf";
  271. 				}
  272. 				else {
  273. 					return "-Inf";
  274. 				}
  275. 			}
  276. 			else if(/nan/i.test(numstr)) {
  277. 				return "NaN";
  278. 			}
  279. 			return numstr;
  280. 		};
  281. 		if(!this.isReal()) {
  282. 			if(this._re === 0) {
  283. 				return formatG(this._im) + "i";
  284. 			}
  285. 			else if((this._im >= 0) || (Number.isNaN(this._im))) {
  286. 				return formatG(this._re) + " + " + formatG(this._im) + "i";
  287. 			}
  288. 			else {
  289. 				return formatG(this._re) + " - " + formatG(-this._im) + "i";
  290. 			}
  291. 		}
  292. 		else {
  293. 			return formatG(this._re);
  294. 		}
  295. 	}
  296.  
  297. 	/**
  298. 	 * Convert to JSON.
  299. 	 * @returns {string} 
  300. 	 */
  301. 	toJSON() {
  302. 		if(!this.isReal()) {
  303. 			if(this._re === 0) {
  304. 				return this._im.toString() + "i";
  305. 			}
  306. 			else if((this._im >= 0) || (Number.isNaN(this._im))) {
  307. 				return this._re.toString() + "+" + this._im.toString() + "i";
  308. 			}
  309. 			else {
  310. 				return this._re.toString() + this._im.toString() + "i";
  311. 			}
  312. 		}
  313. 		else {
  314. 			return this._re.toString();
  315. 		}
  316. 	}
  317. 	
  318. 	/**
  319. 	 * The real part of this Comlex.
  320. 	 * @returns {number} real(A)
  321. 	 */
  322. 	get real() {
  323. 		return this._re;
  324. 	}
  325. 	
  326. 	/**
  327. 	 * The imaginary part of this Comlex.
  328. 	 * @returns {number} imag(A)
  329. 	 */
  330. 	get imag() {
  331. 		return this._im;
  332. 	}
  333.  
  334. 	/**
  335. 	 * norm.
  336. 	 * @returns {number} |A|
  337. 	 */
  338. 	get norm() {
  339. 		if(this._im === 0) {
  340. 			return Math.abs(this._re);
  341. 		}
  342. 		else if(this._re === 0) {
  343. 			return Math.abs(this._im);
  344. 		}
  345. 		else {
  346. 			return Math.sqrt(this._re * this._re + this._im * this._im);
  347. 		}
  348. 	}
  349.  
  350. 	/**
  351. 	 * The argument of this complex number.
  352. 	 * @returns {number} arg(A)
  353. 	 */
  354. 	get arg() {
  355. 		if(this._im === 0) {
  356. 			return this._re >= 0 ? 0 : Math.PI;
  357. 		}
  358. 		else if(this._re === 0) {
  359. 			return Math.PI * (this._im >= 0.0 ? 0.5 : -0.5);
  360. 		}
  361. 		else {
  362. 			return Math.atan2(this._im, this._re);
  363. 		}
  364. 	}
  365.  
  366. 	/**
  367. 	 * Return number of decimal places for real and imaginary parts.
  368. 	 * - Used to make a string.
  369. 	 * @returns {number} Number of decimal places.
  370. 	 */
  371. 	getDecimalPosition() {
  372. 		/**
  373. 		 * @type {function(number): number }
  374. 		 */
  375. 		const getDecimal = function(x) {
  376. 			if(!Number.isFinite(x)) {
  377. 				return 0;
  378. 			}
  379. 			let a = x;
  380. 			let point = 0;
  381. 			for(let i = 0; i < 20; i++) {
  382. 				if(Math.abs(a - Math.round(a)) <= Number.EPSILON) {
  383. 					break;
  384. 				}
  385. 				a *= 10;
  386. 				point++;
  387. 			}
  388. 			return point;
  389. 		};
  390. 		return Math.max( getDecimal(this.real), getDecimal(this.imag) );
  391. 	}
  392.  
  393. 	/**
  394. 	 * The positive or negative sign of this number.
  395. 	 * - +1 if positive, -1 if negative, 0 if 0.
  396. 	 * @returns {Complex} 
  397. 	 */
  398. 	sign() {
  399. 		if(!this.isFinite()) {
  400. 			if(this.isNaN() || this._im === Infinity || this._im === -Infinity) {
  401. 				return Complex.NaN;
  402. 			}
  403. 			if(this._re === Infinity) {
  404. 				return Complex.ONE;
  405. 			}
  406. 			else {
  407. 				return Complex.MINUS_ONE;
  408. 			}
  409. 		}
  410. 		if(this._im === 0) {
  411. 			if(this._re === 0) {
  412. 				return Complex.ZERO;
  413. 			}
  414. 			else {
  415. 				return new Complex(this._re > 0 ? 1 : -1);
  416. 			}
  417. 		}
  418. 		return this.div(this.norm);
  419. 	}
  420. 	
  421. 	// ----------------------
  422. 	// 四則演算
  423. 	// ----------------------
  424. 	
  425. 	/**
  426. 	 * Add.
  427. 	 * @param {KComplexInputData} number 
  428. 	 * @returns {Complex} A + B
  429. 	 */
  430. 	add(number) {
  431. 		const A = this;
  432. 		const B = new Complex(number);
  433. 		B._re = A._re + B._re;
  434. 		B._im = A._im + B._im;
  435. 		return B;
  436. 	}
  437.  
  438. 	/**
  439. 	 * Subtract.
  440. 	 * @param {KComplexInputData} number
  441. 	 * @returns {Complex} A - B
  442. 	 */
  443. 	sub(number) {
  444. 		const A = this;
  445. 		const B = new Complex(number);
  446. 		B._re = A._re - B._re;
  447. 		B._im = A._im - B._im;
  448. 		return B;
  449. 	}
  450.  
  451. 	/**
  452. 	 * Multiply.
  453. 	 * @param {KComplexInputData} number
  454. 	 * @returns {Complex} A * B
  455. 	 */
  456. 	mul(number) {
  457. 		const A = this;
  458. 		const B = new Complex(number);
  459. 		if((A._im === 0) && (B._im === 0)) {
  460. 			B._re = A._re * B._re;
  461. 			return B;
  462. 		}
  463. 		else if((A._re === 0) && (B._re === 0)) {
  464. 			B._re = - A._im * B._im;
  465. 			B._im = 0;
  466. 			return B;
  467. 		}
  468. 		else {
  469. 			const re = A._re * B._re - A._im * B._im;
  470. 			const im = A._im * B._re + A._re * B._im;
  471. 			B._re = re;
  472. 			B._im = im;
  473. 			return B;
  474. 		}
  475. 	}
  476. 	
  477. 	/**
  478. 	 * Inner product/Dot product.
  479. 	 * @param {KComplexInputData} number
  480. 	 * @returns {Complex} A * conj(B)
  481. 	 */
  482. 	dot(number) {
  483. 		const A = this;
  484. 		const B = new Complex(number);
  485. 		if((A._im === 0) && (B._im === 0)) {
  486. 			B._re = A._re * B._re;
  487. 			return B;
  488. 		}
  489. 		else if((A._re === 0) && (B._re === 0)) {
  490. 			B._re = A._im * B._im;
  491. 			B._im = 0;
  492. 			return B;
  493. 		}
  494. 		else {
  495. 			const re =   A._re * B._re + A._im * B._im;
  496. 			const im = - A._im * B._re + A._re * B._im;
  497. 			B._re = re;
  498. 			B._im = im;
  499. 			return B;
  500. 		}
  501. 	}
  502. 	
  503. 	/**
  504. 	 * Divide.
  505. 	 * @param {KComplexInputData} number
  506. 	 * @returns {Complex} A / B
  507. 	 */
  508. 	div(number) {
  509. 		const A = this;
  510. 		const B = new Complex(number);
  511. 		if((A._im === 0) && (B._im === 0)) {
  512. 			B._re = A._re / B._re;
  513. 			return B;
  514. 		}
  515. 		else if((A._re === 0) && (B._re === 0)) {
  516. 			B._re = A._im / B._im;
  517. 			B._im = 0;
  518. 			return B;
  519. 		}
  520. 		else {
  521. 			const re = A._re * B._re + A._im * B._im;
  522. 			const im = A._im * B._re - A._re * B._im;
  523. 			const denominator = 1.0 / (B._re * B._re + B._im * B._im);
  524. 			B._re = re * denominator;
  525. 			B._im = im * denominator;
  526. 			return B;
  527. 		}
  528. 	}
  529.  
  530. 	/**
  531. 	 * Modulo, positive remainder of division.
  532. 	 * - Result has same sign as the Dividend.
  533. 	 * @param {KComplexInputData} number - Divided value (real number only).
  534. 	 * @returns {Complex} A rem B
  535. 	 */
  536. 	rem(number) {
  537. 		const A = this;
  538. 		const B = new Complex(number);
  539. 		if((A._im !== 0) || (B._im !== 0)) {
  540. 			throw "calculation method is undefined.";
  541. 		}
  542. 		if(!A.isFinite() || !B.isFinite() || B.isZero()) {
  543. 			return Complex.NaN;
  544. 		}
  545. 		B._re = A._re - B._re * (Math.trunc(A._re / B._re));
  546. 		return B;
  547. 	}
  548.  
  549. 	/**
  550. 	 * Modulo, positive remainder of division.
  551. 	 * - Result has same sign as the Divisor.
  552. 	 * @param {KComplexInputData} number - Divided value (real number only).
  553. 	 * @returns {Complex} A mod B
  554. 	 */
  555. 	mod(number) {
  556. 		const A = this;
  557. 		const B = new Complex(number);
  558. 		if((A._im !== 0) || (B._im !== 0)) {
  559. 			throw "calculation method is undefined.";
  560. 		}
  561. 		if(B.isZero()) {
  562. 			return A;
  563. 		}
  564. 		const ret = A.rem(B);
  565. 		if(!A.equalsState(B)) {
  566. 			return ret.add(B);
  567. 		}
  568. 		else {
  569. 			return ret;
  570. 		}
  571. 	}
  572.  
  573. 	/**
  574. 	 * Inverse number of this value.
  575. 	 * @returns {Complex} 1 / A
  576. 	 */
  577. 	inv() {
  578. 		if(this._im === 0) {
  579. 			return new Complex(1.0 / this._re);
  580. 		}
  581. 		else if(this._re === 0) {
  582. 			return new Complex([0, - 1.0 / this._im]);
  583. 		}
  584. 		return Complex.ONE.div(this);
  585. 	}
  586.  
  587. 	// ----------------------
  588. 	// 他の型に変換用
  589. 	// ----------------------
  590. 	
  591. 	/**
  592. 	 * boolean value.
  593. 	 * @returns {boolean}
  594. 	 */
  595. 	get booleanValue() {
  596. 		return !this.isZero() && !this.isNaN();
  597. 	}
  598.  
  599. 	/**
  600. 	 * integer value.
  601. 	 * @returns {number}
  602. 	 */
  603. 	get intValue() {
  604. 		if(!this.isFinite()) {
  605. 			return this.isNaN() ? NaN : (this.isPositiveInfinity() ? Infinity : -Infinity);
  606. 		}
  607. 		const value = this._re;
  608. 		const delta = Math.abs(value - Math.trunc(value));
  609. 		if(delta < Number.EPSILON) {
  610. 			return Math.round(value);
  611. 		}
  612. 		else {
  613. 			return Math.trunc(value);
  614. 		}
  615. 	}
  616.  
  617. 	/**
  618. 	 * floating point.
  619. 	 * @returns {number}
  620. 	 */
  621. 	get doubleValue() {
  622. 		if(!this.isFinite()) {
  623. 			return this.isNaN() ? NaN : (this.isPositiveInfinity() ? Infinity : -Infinity);
  624. 		}
  625. 		const value = this._re;
  626. 		const delta = Math.abs(value - Math.trunc(value));
  627. 		if(delta < Number.EPSILON) {
  628. 			return Math.round(value);
  629. 		}
  630. 		else {
  631. 			return value;
  632. 		}
  633. 	}
  634.  
  635. 	// ----------------------
  636. 	// konpeito で扱う数値型へ変換
  637. 	// ----------------------
  638. 	
  639. 	/**
  640. 	 * return BigInteger.
  641. 	 * @returns {BigInteger}
  642. 	 */
  643. 	toBigInteger() {
  644. 		return new BigInteger(this.intValue);
  645. 	}
  646. 	
  647. 	/**
  648. 	 * return BigDecimal.
  649. 	 * @param {MathContext} [mc] - MathContext setting after calculation. 
  650. 	 * @returns {BigDecimal}
  651. 	 */
  652. 	toBigDecimal(mc) {
  653. 		if(mc) {
  654. 			return new BigDecimal([this.doubleValue, mc]);
  655. 		}
  656. 		else {
  657. 			return new BigDecimal(this.doubleValue);
  658. 		}
  659. 	}
  660. 	
  661. 	/**
  662. 	 * return Fraction.
  663. 	 * @returns {Fraction}
  664. 	 */
  665. 	toFraction() {
  666. 		return new Fraction(this.doubleValue);
  667. 	}
  668. 	
  669. 	/**
  670. 	 * return Complex.
  671. 	 * @returns {Complex}
  672. 	 */
  673. 	toComplex() {
  674. 		return this;
  675. 	}
  676. 	
  677. 	/**
  678. 	 * return Matrix.
  679. 	 * @returns {Matrix}
  680. 	 */
  681. 	toMatrix() {
  682. 		return new Matrix(this);
  683. 	}
  684.  
  685. 	// ----------------------
  686. 	// 比較
  687. 	// ----------------------
  688. 	
  689. 	/**
  690. 	 * Equals.
  691. 	 * @param {KComplexInputData} number
  692. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  693. 	 * @returns {boolean} A === B
  694. 	 */
  695. 	equals(number, tolerance) {
  696. 		const A = this;
  697. 		const B = Complex._toComplex(number);
  698. 		// 無限大、非数の値も含めて一度確認
  699. 		if(A.isNaN() || B.isNaN()) {
  700. 			return false;
  701. 		}
  702. 		if((A._re === B._re) && (A._im === B._im)) {
  703. 			return true;
  704. 		}
  705. 		// 誤差を含んだ値の比較
  706. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  707. 		return (Math.abs(A._re - B._re) <  tolerance_) && (Math.abs(A._im - B._im) < tolerance_);
  708. 	}
  709.  
  710. 	/**
  711. 	 * Numeric type match.
  712. 	 * @param {KComplexInputData} number 
  713. 	 * @returns {boolean}
  714. 	 */
  715. 	equalsState(number) {
  716. 		const A = this;
  717. 		const B = Complex._toComplex(number);
  718. 		/**
  719. 		 * @param {Complex} num
  720. 		 * @returns {number}
  721. 		 */
  722. 		const getState = function(num) {
  723. 			if(num.isZero()) {
  724. 				return 0;
  725. 			}
  726. 			if(!num.isFinite()) {
  727. 				if(num.isPositiveInfinity()) {
  728. 					return 4;
  729. 				}
  730. 				else if(num.isNegativeInfinity()) {
  731. 					return 5;
  732. 				}
  733. 				else {
  734. 					return 3;
  735. 				}
  736. 			}
  737. 			return num.isPositive() ? 1 : 2;
  738. 		};
  739. 		const A_type = getState(A);
  740. 		const B_type = getState(B);
  741. 		return A_type === B_type;
  742. 	}
  743.  
  744. 	/**
  745. 	 * Compare values.
  746. 	 * @param {KComplexInputData} number
  747. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  748. 	 * @returns {number} A > B ? 1 : (A === B ? 0 : -1)
  749. 	 */
  750. 	compareTo(number, tolerance) {
  751. 		const A = this;
  752. 		const B = Complex._toComplex(number);
  753. 		if(!A.isFinite() || !B.isFinite()) {
  754. 			if(A.equals(B)) {
  755. 				return 0;
  756. 			}
  757. 			else if(
  758. 				A.isNaN() || B.isNaN() ||
  759. 				(A.real ===  Infinity && A.imag === -Infinity) ||
  760. 				(A.real === -Infinity && A.imag ===  Infinity) ||
  761. 				(B.real ===  Infinity && B.imag === -Infinity) ||
  762. 				(B.real === -Infinity && B.imag ===  Infinity) ) {
  763. 				return NaN;
  764. 			}
  765. 			else if(A.isFinite()) {
  766. 				return B.real + B.imag < 0 ? 1 : -1;
  767. 			}
  768. 			else if(B.isFinite()) {
  769. 				return A.real + A.imag > 0 ? 1 : -1;
  770. 			}
  771. 			else {
  772. 				return NaN;
  773. 			}
  774. 		}
  775. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  776. 		const a = A.real + A.imag;
  777. 		const b = B.real + B.imag;
  778. 		if((Math.abs(a - b) <= tolerance_)) {
  779. 			return 0;
  780. 		}
  781. 		return a > b ? 1 : -1;
  782. 	}
  783. 	
  784. 	/**
  785. 	 * Maximum number.
  786. 	 * @param {KComplexInputData} number
  787. 	 * @returns {Complex} max([A, B])
  788. 	 */
  789. 	max(number) {
  790. 		const x = Complex._toComplex(number);
  791. 		if(this.compareTo(x) >= 0) {
  792. 			return this;
  793. 		}
  794. 		else {
  795. 			return x;
  796. 		}
  797. 	}
  798.  
  799. 	/**
  800. 	 * Minimum number.
  801. 	 * @param {KComplexInputData} number
  802. 	 * @returns {Complex} min([A, B])
  803. 	 */
  804. 	min(number) {
  805. 		const x = Complex._toComplex(number);
  806. 		if(this.compareTo(x) <= 0) {
  807. 			return this;
  808. 		}
  809. 		else {
  810. 			return x;
  811. 		}
  812. 	}
  813.  
  814. 	/**
  815. 	 * Clip number within range.
  816. 	 * @param {KComplexInputData} min 
  817. 	 * @param {KComplexInputData} max
  818. 	 * @returns {Complex} min(max(x, min), max)
  819. 	 */
  820. 	clip(min, max) {
  821. 		const min_ = Complex._toComplex(min);
  822. 		const max_ = Complex._toComplex(max);
  823. 		const arg_check = min_.compareTo(max_);
  824. 		if(arg_check === 1) {
  825. 			throw "clip(min, max) error. (min > max)->(" + min_ + " > " + max_ + ")";
  826. 		}
  827. 		else if(arg_check === 0) {
  828. 			return min_;
  829. 		}
  830. 		if(this.compareTo(max_) === 1) {
  831. 			return max_;
  832. 		}
  833. 		else if(this.compareTo(min_) === -1) {
  834. 			return min_;
  835. 		}
  836. 		return this;
  837. 	}
  838.  
  839. 	// ----------------------
  840. 	// 丸め
  841. 	// ----------------------
  842. 	
  843. 	/**
  844. 	 * Floor.
  845. 	 * @returns {Complex} floor(A)
  846. 	 */
  847. 	floor() {
  848. 		return new Complex([Math.floor(this._re), Math.floor(this._im)]);
  849. 	}
  850.  
  851. 	/**
  852. 	 * Ceil.
  853. 	 * @returns {Complex} ceil(A)
  854. 	 */
  855. 	ceil() {
  856. 		return new Complex([Math.ceil(this._re), Math.ceil(this._im)]);
  857. 	}
  858. 	
  859. 	/**
  860. 	 * Rounding to the nearest integer.
  861. 	 * @returns {Complex} round(A)
  862. 	 */
  863. 	round() {
  864. 		return new Complex([Math.round(this._re), Math.round(this._im)]);
  865. 	}
  866.  
  867. 	/**
  868. 	 * To integer rounded down to the nearest.
  869. 	 * @returns {Complex} fix(A), trunc(A)
  870. 	 */
  871. 	fix() {
  872. 		return new Complex([Math.trunc(this._re), Math.trunc(this._im)]);
  873. 	}
  874.  
  875. 	/**
  876. 	 * Fraction.
  877. 	 * @returns {Complex} fract(A)
  878. 	 */
  879. 	fract() {
  880. 		return new Complex([this._re - Math.floor(this._re), this._im - Math.floor(this._im)]);
  881. 	}
  882.  
  883. 	// ----------------------
  884. 	// 複素数
  885. 	// ----------------------
  886. 	
  887. 	/**
  888. 	 * Absolute value.
  889. 	 * @returns {Complex} abs(A)
  890. 	 */
  891. 	abs() {
  892. 		return new Complex(this.norm);
  893. 	}
  894.  
  895. 	/**
  896. 	 * Complex conjugate.
  897. 	 * @returns {Complex} real(A) - imag(A)j
  898. 	 */
  899. 	conj() {
  900. 		if(this._im === 0) {
  901. 			return this;
  902. 		}
  903. 		// 共役複素数
  904. 		return new Complex([this._re, -this._im]);
  905. 	}
  906.  
  907. 	/**
  908. 	 * this * -1
  909. 	 * @returns {Complex} -A
  910. 	 */
  911. 	negate() {
  912. 		return new Complex([-this._re, -this._im]);
  913. 	}
  914.  
  915. 	// ----------------------
  916. 	// 指数
  917. 	// ----------------------
  918. 	
  919. 	/**
  920. 	 * Power function.
  921. 	 * @param {KComplexInputData} number
  922. 	 * @returns {Complex} pow(A, B)
  923. 	 */
  924. 	pow(number) {
  925. 		const A = this;
  926. 		const B = new Complex(number);
  927. 		// -2 ^ 0.5 ... 複素数
  928. 		// -2 ^ 1   ... 実数
  929. 		//  2 ^ 0.5 ... 実数
  930. 		if(B.isReal()) {
  931. 			if(A.isReal() && (A.isNotNegative() || B.isInteger())) {
  932. 				B._re = Math.pow(A._re, B._re);
  933. 				return B;
  934. 			}
  935. 			else {
  936. 				const r = Math.pow(A.norm, B._re);
  937. 				const s = A.arg * B._re;
  938. 				B._re = r * Math.cos(s);
  939. 				B._im = r * Math.sin(s);
  940. 				return B;
  941. 			}
  942. 		}
  943. 		else {
  944. 			return B.mul(A.log()).exp();
  945. 		}
  946. 	}
  947.  
  948. 	/**
  949. 	 * Square.
  950. 	 * @returns {Complex} pow(A, 2)
  951. 	 */
  952. 	square() {
  953. 		if(this._im === 0.0) {
  954. 			return new Complex(this._re * this._re);
  955. 		}
  956. 		return this.mul(this);
  957. 	}
  958.  
  959. 	/**
  960. 	 * Square root.
  961. 	 * @returns {Complex} sqrt(A)
  962. 	 */
  963. 	sqrt() {
  964. 		if(this.isReal()) {
  965. 			if(this.isNotNegative()) {
  966. 				return new Complex(Math.sqrt(this._re));
  967. 			}
  968. 			else {
  969. 				return new Complex([0, Math.sqrt(-this._re)]);
  970. 			}
  971. 		}
  972. 		const r = Math.sqrt(this.norm);
  973. 		const s = this.arg * 0.5;
  974. 		return new Complex([r * Math.cos(s), r * Math.sin(s)]);
  975. 	}
  976.  
  977. 	/**
  978. 	 * Cube root.
  979. 	 * @param {KComplexInputData} [n=0] - Value type(0,1,2)
  980. 	 * @returns {Complex} cbrt(A)
  981. 	 */
  982. 	cbrt(n) {
  983. 		const type = Complex._toInteger(n !== undefined ? n : 0);
  984. 		const x = this.log().div(3).exp();
  985. 		if(type === 0) {
  986. 			return x;
  987. 		}
  988. 		else if(type === 1) {
  989. 			return x.mul([-0.5, Math.sqrt(3) * 0.5]);
  990. 		}
  991. 		else {
  992. 			return x.mul([-0.5, - Math.sqrt(3) * 0.5]);
  993. 		}
  994. 	}
  995.  
  996. 	/**
  997. 	 * Reciprocal square root.
  998. 	 * @returns {Complex} rsqrt(A)
  999. 	 */
  1000. 	rsqrt() {
  1001. 		if(this.isReal()) {
  1002. 			if(this.isNotNegative()) {
  1003. 				return new Complex(1.0 / Math.sqrt(this._re));
  1004. 			}
  1005. 			else {
  1006. 				return new Complex([0, - 1.0 / Math.sqrt(-this._re)]);
  1007. 			}
  1008. 		}
  1009. 		return this.sqrt().inv();
  1010. 	}
  1011.  
  1012. 	/**
  1013. 	 * Logarithmic function.
  1014. 	 * @returns {Complex} log(A)
  1015. 	 */
  1016. 	log() {
  1017. 		if(this.isReal() && this.isNotNegative()) {
  1018. 			return new Complex(Math.log(this._re));
  1019. 		}
  1020. 		// 負の値が入っているか、もともと複素数が入っている場合は、複素対数関数
  1021. 		return new Complex([Math.log(this.norm), this.arg]);
  1022. 	}
  1023.  
  1024. 	/**
  1025. 	 * Exponential function.
  1026. 	 * @returns {Complex} exp(A)
  1027. 	 */
  1028. 	exp() {
  1029. 		if(this.isReal()) {
  1030. 			return new Complex(Math.exp(this._re));
  1031. 		}
  1032. 		// 複素指数関数
  1033. 		const r = Math.exp(this._re);
  1034. 		return new Complex([r * Math.cos(this._im), r * Math.sin(this._im)]);
  1035. 	}
  1036.  
  1037. 	/**
  1038. 	 * e^x - 1
  1039. 	 * @returns {Complex} expm1(A)
  1040. 	 */
  1041. 	expm1() {
  1042. 		return this.exp().sub(1);
  1043. 	}
  1044.  
  1045. 	/**
  1046. 	 * ln(1 + x)
  1047. 	 * @returns {Complex} log1p(A)
  1048. 	 */
  1049. 	log1p() {
  1050. 		return this.add(1).log();
  1051. 	}
  1052. 	
  1053. 	/**
  1054. 	 * log_2(x)
  1055. 	 * @returns {Complex} log2(A)
  1056. 	 */
  1057. 	log2() {
  1058. 		return this.log().div(Complex.LN2);
  1059. 		
  1060. 	}
  1061.  
  1062. 	/**
  1063. 	 * log_10(x)
  1064. 	 * @returns {Complex} log10(A)
  1065. 	 */
  1066. 	log10() {
  1067. 		return this.log().div(Complex.LN10);
  1068. 	}
  1069.  
  1070. 	// ----------------------
  1071. 	// 三角関数
  1072. 	// ----------------------
  1073. 	
  1074. 	/**
  1075. 	 * Sine function.
  1076. 	 * @returns {Complex} sin(A)
  1077. 	 */
  1078. 	sin() {
  1079. 		if(this.isReal()) {
  1080. 			return new Complex(Math.sin(this._re));
  1081. 		}
  1082. 		// オイラーの公式より
  1083. 		// sin x = (e^ix - e^-ex) / 2i
  1084. 		const a = this.mul(Complex.I).exp();
  1085. 		const b = this.mul(Complex.I.negate()).exp();
  1086. 		return a.sub(b).div([0, 2]);
  1087. 	}
  1088.  
  1089. 	/**
  1090. 	 * Cosine function.
  1091. 	 * @returns {Complex} cos(A)
  1092. 	 */
  1093. 	cos() {
  1094. 		if(this.isReal()) {
  1095. 			return new Complex(Math.cos(this._re));
  1096. 		}
  1097. 		// オイラーの公式より
  1098. 		// cos x = (e^ix + e^-ex) / 2
  1099. 		const a = this.mul(Complex.I).exp();
  1100. 		const b = this.mul(Complex.I.negate()).exp();
  1101. 		return a.add(b).div(2);
  1102. 	}
  1103.  
  1104. 	/**
  1105. 	 * Tangent function.
  1106. 	 * @returns {Complex} tan(A)
  1107. 	 */
  1108. 	tan() {
  1109. 		if(this.isReal()) {
  1110. 			return new Complex(Math.tan(this._re));
  1111. 		}
  1112. 		// 三角関数の相互関係 tan x = sin x / cos x
  1113. 		return this.sin().div(this.cos());
  1114. 	}
  1115.  
  1116. 	/**
  1117. 	 * Atan (arc tangent) function.
  1118. 	 * - Return the values of [-PI/2, PI/2].
  1119. 	 * @returns {Complex} atan(A)
  1120. 	 */
  1121. 	atan() {
  1122. 		if(this.isReal()) {
  1123. 			return new Complex(Math.atan(this._re));
  1124. 		}
  1125. 		// 逆正接 tan-1 x = i/2 log( i+x / i-x )
  1126. 		return Complex.I.div(Complex.TWO).mul(Complex.I.add(this).div(Complex.I.sub(this)).log());
  1127. 	}
  1128.  
  1129. 	/**
  1130. 	 * Atan (arc tangent) function.
  1131. 	 * Return the values of [-PI, PI] .
  1132. 	 * Supports only real numbers.
  1133. 	 * @param {KComplexInputData} [number] - X
  1134. 	 * @returns {Complex} atan2(Y, X)
  1135. 	 */
  1136. 	atan2(number) {
  1137. 		if(arguments.length === 0) {
  1138. 			return new Complex(this.arg);
  1139. 		}
  1140. 		// y.atan2(x) とする。
  1141. 		const y = this;
  1142. 		const x = Complex._toComplex(number);
  1143. 		if(y.isReal() && x.isReal()) {
  1144. 			return new Complex(Math.atan2(y._re, x._re));
  1145. 		}
  1146. 		// 複素数のatan2は未定義である（実装不可能）
  1147. 		throw "calculation method is undefined.";
  1148. 	}
  1149. 	
  1150. 	// ----------------------
  1151. 	// 双曲線関数
  1152. 	// ----------------------
  1153. 	
  1154. 	/**
  1155. 	 * Arc sine function.
  1156. 	 * @returns {Complex} asin(A)
  1157. 	 */
  1158. 	asin() {
  1159. 		// 逆正弦
  1160. 		return this.mul(Complex.I).add(Complex.ONE.sub(this.square()).sqrt()).log().mul(Complex.MINUS_I);
  1161. 	}
  1162.  
  1163. 	/**
  1164. 	 * Arc cosine function.
  1165. 	 * @returns {Complex} acos(A)
  1166. 	 */
  1167. 	acos() {
  1168. 		// 逆余弦
  1169. 		return this.add(Complex.I.mul(Complex.ONE.sub(this.square()).sqrt())).log().mul(Complex.MINUS_I);
  1170. 	}
  1171. 	
  1172.  
  1173. 	/**
  1174. 	 * Hyperbolic sine function.
  1175. 	 * @returns {Complex} sinh(A)
  1176. 	 */
  1177. 	sinh() {
  1178. 		// 双曲線正弦
  1179. 		const y = this.exp();
  1180. 		return y.sub(y.inv()).mul(0.5);
  1181. 	}
  1182.  
  1183. 	/**
  1184. 	 * Inverse hyperbolic sine function.
  1185. 	 * @returns {Complex} asinh(A)
  1186. 	 */
  1187. 	asinh() {
  1188. 		// 逆双曲線正弦 Math.log(x + Math.sqrt(x * x + 1));
  1189. 		if(this.isInfinite()) {
  1190. 			return this;
  1191. 		}
  1192. 		return this.add(this.mul(this).add(1).sqrt()).log();
  1193. 	}
  1194.  
  1195. 	/**
  1196. 	 * Hyperbolic cosine function.
  1197. 	 * @returns {Complex} cosh(A)
  1198. 	 */
  1199. 	cosh() {
  1200. 		// 双曲線余弦
  1201. 		return this.exp().add(this.negate().exp()).mul(0.5);
  1202. 	}
  1203.  
  1204. 	/**
  1205. 	 * Inverse hyperbolic cosine function.
  1206. 	 * @returns {Complex} acosh(A)
  1207. 	 */
  1208. 	acosh() {
  1209. 		// 逆双曲線余弦 Math.log(x + Math.sqrt(x * x - 1));
  1210. 		// Octave だと log(0.5+(0.5*0.5-1)^0.5) !== acosh(0.5) になる。
  1211. 		// おそらく log(0.5-(0.5*0.5-1)^0.5) の式に切り替わるようになっている
  1212. 		// これは2つの値を持っているためだと思われるので合わせてみる
  1213. 		if(this.isZero()) {
  1214. 			return new Complex([0, Math.PI * 0.5]);
  1215. 		}
  1216. 		if(this.compareTo(Complex.ONE) >= 1) {
  1217. 			return this.add(this.square().sub(1).sqrt()).log();
  1218. 		}
  1219. 		else {
  1220. 			return this.sub(this.square().sub(1).sqrt()).log();
  1221. 		}
  1222. 	}
  1223.  
  1224. 	/**
  1225. 	 * Hyperbolic tangent function.
  1226. 	 * @returns {Complex} tanh(A)
  1227. 	 */
  1228. 	tanh() {
  1229. 		// 双曲線正接
  1230. 		if(this.isNaN()) {
  1231. 			return Complex.NaN;
  1232. 		}
  1233. 		const y =  this.mul(2).exp();
  1234. 		if(y.isZero()) {
  1235. 			return Complex.MINUS_ONE;
  1236. 		}
  1237. 		else if(y.isPositiveInfinity()) {
  1238. 			return Complex.ONE;
  1239. 		}
  1240. 		return y.sub(1).div(y.add(1));
  1241. 	}
  1242. 	
  1243. 	/**
  1244. 	 * Inverse hyperbolic tangent function.
  1245. 	 * @returns {Complex} atanh(A)
  1246. 	 */
  1247. 	atanh() {
  1248. 		// 逆双曲線正接
  1249. 		if(this.isInfinite() && this.isReal()) {
  1250. 			return new Complex([0, Math.PI * 0.5]);
  1251. 		}
  1252. 		return this.add(1).div(this.negate().add(1)).log().mul(0.5);
  1253. 	}
  1254.  
  1255. 	/**
  1256. 	 * Secant function.
  1257. 	 * @returns {Complex} sec(A)
  1258. 	 */
  1259. 	sec() {
  1260. 		// 正割
  1261. 		return this.cos().inv();
  1262. 	}
  1263.  
  1264. 	/**
  1265. 	 * Reverse secant function.
  1266. 	 * @returns {Complex} asec(A)
  1267. 	 */
  1268. 	asec() {
  1269. 		// 逆正割
  1270. 		return this.inv().acos();
  1271. 	}
  1272.  
  1273. 	/**
  1274. 	 * Hyperbolic secant function.
  1275. 	 * @returns {Complex} sech(A)
  1276. 	 */
  1277. 	sech() {
  1278. 		// 双曲線正割
  1279. 		return this.exp().add(this.negate().exp()).inv().mul(2);
  1280. 	}
  1281.  
  1282. 	/**
  1283. 	 * Inverse hyperbolic secant function.
  1284. 	 * @returns {Complex} asech(A)
  1285. 	 */
  1286. 	asech() {
  1287. 		// 逆双曲線正割
  1288. 		if(this.isInfinite() && this.isReal()) {
  1289. 			return new Complex([0, Math.PI * 0.5]);
  1290. 		}
  1291. 		if(this.isPositive() || (this.compareTo(Complex.MINUS_ONE) == -1)) {
  1292. 			return this.inv().add(this.square().inv().sub(1).sqrt()).log();
  1293. 		}
  1294. 		else {
  1295. 			return this.inv().sub(this.square().inv().sub(1).sqrt()).log();
  1296. 		}
  1297. 	}
  1298.  
  1299. 	/**
  1300. 	 * Cotangent function.
  1301. 	 * @returns {Complex} cot(A)
  1302. 	 */
  1303. 	cot() {
  1304. 		// 余接
  1305. 		return this.tan().inv();
  1306. 	}
  1307.  
  1308. 	/**
  1309. 	 * Inverse cotangent function.
  1310. 	 * @returns {Complex} acot(A)
  1311. 	 */
  1312. 	acot() {
  1313. 		// 逆余接
  1314. 		return this.inv().atan();
  1315. 	}
  1316.  
  1317. 	/**
  1318. 	 * Hyperbolic cotangent function.
  1319. 	 * @returns {Complex} coth(A)
  1320. 	 */
  1321. 	coth() {
  1322. 		// 双曲線余接
  1323. 		if(this.isZero()) {
  1324. 			return Complex.POSITIVE_INFINITY;
  1325. 		}
  1326. 		return this.tanh().inv();
  1327. 	}
  1328.  
  1329. 	/**
  1330. 	 * Inverse hyperbolic cotangent function.
  1331. 	 * @returns {Complex} acoth(A)
  1332. 	 */
  1333. 	acoth() {
  1334. 		// 逆双曲線余接
  1335. 		if(this.isInfinite()) {
  1336. 			return Complex.ZERO;
  1337. 		}
  1338. 		return this.add(1).div(this.sub(1)).log().mul(0.5);
  1339. 	}
  1340.  
  1341. 	/**
  1342. 	 * Cosecant function.
  1343. 	 * @returns {Complex} csc(A)
  1344. 	 */
  1345. 	csc() {
  1346. 		// 余割
  1347. 		return this.sin().inv();
  1348. 	}
  1349.  
  1350. 	/**
  1351. 	 * Inverse cosecant function.
  1352. 	 * @returns {Complex} acsc(A)
  1353. 	 */
  1354. 	acsc() {
  1355. 		// 逆余割
  1356. 		return this.inv().asin();
  1357. 	}
  1358.  
  1359. 	/**
  1360. 	 * Hyperbolic cosecant function.
  1361. 	 * @returns {Complex} csch(A)
  1362. 	 */
  1363. 	csch() {
  1364. 		// 双曲線余割
  1365. 		return this.exp().sub(this.negate().exp()).inv().mul(2);
  1366. 	}
  1367.  
  1368. 	/**
  1369. 	 * Inverse hyperbolic cosecant function.
  1370. 	 * @returns {Complex} acsch(A)
  1371. 	 */
  1372. 	acsch() {
  1373. 		// 逆双曲線余割
  1374. 		return this.inv().add(this.square().inv().add(1).sqrt()).log();
  1375. 	}
  1376.  
  1377. 	// ----------------------
  1378. 	// 確率・統計系
  1379. 	// ----------------------
  1380. 	
  1381. 	/**
  1382. 	 * Logit function.
  1383. 	 * @returns {Complex} logit(A)
  1384. 	 */
  1385. 	logit() {
  1386. 		return this.log().sub(Complex.ONE.sub(this).log());
  1387. 	}
  1388.  
  1389. 	// ----------------------
  1390. 	// 信号処理系
  1391. 	// ----------------------
  1392. 	
  1393. 	/**
  1394. 	 * Normalized sinc function.
  1395. 	 * @returns {Complex} sinc(A)
  1396. 	 */
  1397. 	sinc() {
  1398. 		if(this.isReal()) {
  1399. 			if(this._re === 0) {
  1400. 				return(Complex.ONE);
  1401. 			}
  1402. 			const x = Math.PI * this._re;
  1403. 			return new Complex(Math.sin(x) / x);
  1404. 		}
  1405. 		const x = this.mul(Complex.PI);
  1406. 		return new Complex( x.sin().div(x) );
  1407. 	}
  1408.  
  1409. 	// ----------------------
  1410. 	// 乱数
  1411. 	// ----------------------
  1412. 	
  1413. 	/**
  1414. 	 * Create random values [0, 1) with uniform random numbers.
  1415. 	 * @param {Random} [random] - Class for creating random numbers.
  1416. 	 * @returns {Complex}
  1417. 	 */
  1418. 	static rand(random) {
  1419. 		const rand = (random !== undefined && random instanceof Random) ? random : random_class;
  1420. 		return new Complex(rand.nextDouble());
  1421. 	}
  1422.  
  1423. 	/**
  1424. 	 * Create random values with normal distribution.
  1425. 	 * @param {Random} [random] - Class for creating random numbers.
  1426. 	 * @returns {Complex}
  1427. 	 */
  1428. 	static randn(random) {
  1429. 		const rand = (random !== undefined && random instanceof Random) ? random : random_class;
  1430. 		return new Complex(rand.nextGaussian());
  1431. 	}
  1432.  
  1433. 	// ----------------------
  1434. 	// テスト系
  1435. 	// ----------------------
  1436. 	
  1437. 	/**
  1438. 	 * Return true if the value is integer.
  1439. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1440. 	 * @returns {boolean}
  1441. 	 */
  1442. 	isInteger(tolerance) {
  1443. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1444. 		return this.isReal() && (Math.abs(this._re - Math.trunc(this._re)) < tolerance_);
  1445. 	}
  1446.  
  1447. 	/**
  1448. 	 * Returns true if the vallue is complex integer (including normal integer).
  1449. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1450. 	 * @returns {boolean} real(A) === integer && imag(A) === integer
  1451. 	 */
  1452. 	isComplexInteger(tolerance) {
  1453. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1454. 		// 複素整数
  1455. 		return (Math.abs(this._re - Math.trunc(this._re)) < tolerance_) &&
  1456. 				(Math.abs(this._im - Math.trunc(this._im)) < tolerance_);
  1457. 	}
  1458.  
  1459. 	/**
  1460. 	 * this === 0
  1461. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1462. 	 * @returns {boolean} A === 0
  1463. 	 */
  1464. 	isZero(tolerance) {
  1465. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1466. 		return (Math.abs(this._re) < tolerance_) && (Math.abs(this._im) < tolerance_);
  1467. 	}
  1468.  
  1469. 	/**
  1470. 	 * this === 1
  1471. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1472. 	 * @returns {boolean} A === 1
  1473. 	 */
  1474. 	isOne(tolerance) {
  1475. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1476. 		return (Math.abs(this._re - 1.0) < tolerance_) && (Math.abs(this._im) < tolerance_);
  1477. 	}
  1478.  
  1479. 	/**
  1480. 	 * Returns true if the vallue is complex number (imaginary part is not 0).
  1481. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1482. 	 * @returns {boolean} imag(A) !== 0
  1483. 	 */
  1484. 	isComplex(tolerance) {
  1485. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1486. 		return (Math.abs(this._im) >= tolerance_);
  1487. 	}
  1488. 	
  1489. 	/**
  1490. 	 * Return true if the value is real number.
  1491. 	 * @param {KComplexInputData} [tolerance=Number.EPSILON] - Calculation tolerance of calculation.
  1492. 	 * @returns {boolean} imag(A) === 0
  1493. 	 */
  1494. 	isReal(tolerance) {
  1495. 		const tolerance_ = tolerance ? Complex._toDouble(tolerance) : Number.EPSILON;
  1496. 		return (Math.abs(this._im) < tolerance_);
  1497. 	}
  1498.  
  1499. 	/**
  1500. 	 * this === NaN
  1501. 	 * @returns {boolean} isNaN(A)
  1502. 	 */
  1503. 	isNaN() {
  1504. 		return isNaN(this._re) || isNaN(this._im);
  1505. 	}
  1506.  
  1507. 	/**
  1508. 	 * Return true if this real part of the complex positive.
  1509. 	 * @returns {boolean} real(x) > 0
  1510. 	 */
  1511. 	isPositive() {
  1512. 		// Number.EPSILONは使用しない。どちらにぶれるか不明な点及び
  1513. 		// わずかな負の数だった場合に、sqrtでエラーが発生するため
  1514. 		return 0.0 < this._re;
  1515. 	}
  1516.  
  1517. 	/**
  1518. 	 * real(this) < 0
  1519. 	 * @returns {boolean} real(x) < 0
  1520. 	 */
  1521. 	isNegative() {
  1522. 		return 0.0 > this._re;
  1523. 	}
  1524.  
  1525. 	/**
  1526. 	 * real(this) >= 0
  1527. 	 * @returns {boolean} real(x) >= 0
  1528. 	 */
  1529. 	isNotNegative() {
  1530. 		return 0.0 <= this._re;
  1531. 	}
  1532.  
  1533. 	/**
  1534. 	 * this === Infinity
  1535. 	 * @returns {boolean} isPositiveInfinity(A)
  1536. 	 */
  1537. 	isPositiveInfinity() {
  1538. 		return this._re === Number.POSITIVE_INFINITY || this._im === Number.POSITIVE_INFINITY;
  1539. 	}
  1540.  
  1541. 	/**
  1542. 	 * this === -Infinity
  1543. 	 * @returns {boolean} isNegativeInfinity(A)
  1544. 	 */
  1545. 	isNegativeInfinity() {
  1546. 		return this._re === Number.NEGATIVE_INFINITY || this._im === Number.NEGATIVE_INFINITY;
  1547. 	}
  1548.  
  1549. 	/**
  1550. 	 * this === Infinity or -Infinity
  1551. 	 * @returns {boolean} isPositiveInfinity(A) || isNegativeInfinity(A)
  1552. 	 */
  1553. 	isInfinite() {
  1554. 		return this.isPositiveInfinity() || this.isNegativeInfinity();
  1555. 	}
  1556. 	
  1557. 	/**
  1558. 	 * Return true if the value is finite number.
  1559. 	 * @returns {boolean} !isNaN(A) && !isInfinite(A)
  1560. 	 */
  1561. 	isFinite() {
  1562. 		return !this.isNaN() && !this.isInfinite();
  1563. 	}
  1564.  
  1565. 	// ----------------------
  1566. 	// 確率
  1567. 	// ----------------------
  1568. 	
  1569. 	/**
  1570. 	 * Log-gamma function.
  1571. 	 * - Calculate from real values.
  1572. 	 * @returns {Complex}
  1573. 	 */
  1574. 	gammaln() {
  1575. 		return new Complex(Probability.gammaln(this._re));
  1576. 	}
  1577. 	
  1578. 	/**
  1579. 	 * Gamma function.
  1580. 	 * - Calculate from real values.
  1581. 	 * @returns {Complex}
  1582. 	 */
  1583. 	gamma() {
  1584. 		return new Complex(Probability.gamma(this._re));
  1585. 	}
  1586. 	
  1587. 	/**
  1588. 	 * Incomplete gamma function.
  1589. 	 * - Calculate from real values.
  1590. 	 * @param {KComplexInputData} a
  1591. 	 * @param {string} [tail="lower"] - lower (default) , "upper"
  1592. 	 * @returns {Complex}
  1593. 	 */
  1594. 	gammainc(a, tail) {
  1595. 		const a_ = Complex._toDouble(a);
  1596. 		return new Complex(Probability.gammainc(this._re, a_, tail));
  1597. 	}
  1598.  
  1599. 	/**
  1600. 	 * Probability density function (PDF) of the gamma distribution.
  1601. 	 * - Calculate from real values.
  1602. 	 * @param {KComplexInputData} k - Shape parameter.
  1603. 	 * @param {KComplexInputData} s - Scale parameter.
  1604. 	 * @returns {Complex}
  1605. 	 */
  1606. 	gampdf(k, s) {
  1607. 		const k_ = Complex._toDouble(k);
  1608. 		const s_ = Complex._toDouble(s);
  1609. 		return new Complex(Probability.gampdf(this._re, k_, s_));
  1610. 	}
  1611.  
  1612. 	/**
  1613. 	 * Cumulative distribution function (CDF) of gamma distribution.
  1614. 	 * - Calculate from real values.
  1615. 	 * @param {KComplexInputData} k - Shape parameter.
  1616. 	 * @param {KComplexInputData} s - Scale parameter.
  1617. 	 * @returns {Complex}
  1618. 	 */
  1619. 	gamcdf(k, s) {
  1620. 		const k_ = Complex._toDouble(k);
  1621. 		const s_ = Complex._toDouble(s);
  1622. 		return new Complex(Probability.gamcdf(this._re, k_, s_));
  1623. 	}
  1624.  
  1625. 	/**
  1626. 	 * Inverse function of cumulative distribution function (CDF) of gamma distribution.
  1627. 	 * - Calculate from real values.
  1628. 	 * @param {KComplexInputData} k - Shape parameter.
  1629. 	 * @param {KComplexInputData} s - Scale parameter.
  1630. 	 * @returns {Complex}
  1631. 	 */
  1632. 	gaminv(k, s) {
  1633. 		const k_ = Complex._toDouble(k);
  1634. 		const s_ = Complex._toDouble(s);
  1635. 		return new Complex(Probability.gaminv(this._re, k_, s_));
  1636. 	}
  1637.  
  1638. 	/**
  1639. 	 * Beta function.
  1640. 	 * - Calculate from real values.
  1641. 	 * @param {KComplexInputData} y
  1642. 	 * @returns {Complex}
  1643. 	 */
  1644. 	beta(y) {
  1645. 		const y_ = Complex._toDouble(y);
  1646. 		return new Complex(Probability.beta(this._re, y_));
  1647. 	}
  1648.  
  1649. 	/**
  1650. 	 * Incomplete beta function.
  1651. 	 * - Calculate from real values.
  1652. 	 * @param {KComplexInputData} a
  1653. 	 * @param {KComplexInputData} b
  1654. 	 * @param {string} [tail="lower"] - lower (default) , "upper"
  1655. 	 * @returns {Complex}
  1656. 	 */
  1657. 	betainc(a, b, tail) {
  1658. 		const a_ = Complex._toDouble(a);
  1659. 		const b_ = Complex._toDouble(b);
  1660. 		return new Complex(Probability.betainc(this._re, a_, b_, tail));
  1661. 	}
  1662.  
  1663. 	/**
  1664. 	 * Probability density function (PDF) of beta distribution.
  1665. 	 * - Calculate from real values.
  1666. 	 * @param {KComplexInputData} a
  1667. 	 * @param {KComplexInputData} b
  1668. 	 * @returns {Complex}
  1669. 	 */
  1670. 	betapdf(a, b) {
  1671. 		const a_ = Complex._toDouble(a);
  1672. 		const b_ = Complex._toDouble(b);
  1673. 		return new Complex(Probability.betapdf(this._re, a_, b_));
  1674. 	}
  1675.  
  1676. 	/**
  1677. 	 * Cumulative distribution function (CDF) of beta distribution.
  1678. 	 * - Calculate from real values.
  1679. 	 * @param {KComplexInputData} a
  1680. 	 * @param {KComplexInputData} b
  1681. 	 * @returns {Complex}
  1682. 	 */
  1683. 	betacdf(a, b) {
  1684. 		const a_ = Complex._toDouble(a);
  1685. 		const b_ = Complex._toDouble(b);
  1686. 		return new Complex(Probability.betacdf(this._re, a_, b_));
  1687. 	}
  1688.  
  1689. 	/**
  1690. 	 * Inverse function of cumulative distribution function (CDF) of beta distribution.
  1691. 	 * - Calculate from real values.
  1692. 	 * @param {KComplexInputData} a
  1693. 	 * @param {KComplexInputData} b
  1694. 	 * @returns {Complex}
  1695. 	 */
  1696. 	betainv(a, b) {
  1697. 		const a_ = Complex._toDouble(a);
  1698. 		const b_ = Complex._toDouble(b);
  1699. 		return new Complex(Probability.betainv(this._re, a_, b_));
  1700. 	}
  1701.  
  1702. 	/**
  1703. 	 * Factorial function, x!.
  1704. 	 * - Calculate from real values.
  1705. 	 * @returns {Complex}
  1706. 	 */
  1707. 	factorial() {
  1708. 		return new Complex(Probability.factorial(this._re));
  1709. 	}
  1710.  
  1711. 	/**
  1712. 	 * Binomial coefficient, number of all combinations, nCk.
  1713. 	 * - Calculate from real values.
  1714. 	 * @param {KComplexInputData} k
  1715. 	 * @returns {Complex}
  1716. 	 */
  1717. 	nchoosek(k) {
  1718. 		const k_ = Complex._toDouble(k);
  1719. 		return new Complex(Probability.nchoosek(this._re, k_));
  1720. 	}
  1721. 	
  1722. 	/**
  1723. 	 * Error function.
  1724. 	 * - Calculate from real values.
  1725. 	 * @returns {Complex}
  1726. 	 */
  1727. 	erf() {
  1728. 		return new Complex(Probability.erf(this._re));
  1729. 	}
  1730.  
  1731. 	/**
  1732. 	 * Complementary error function.
  1733. 	 * - Calculate from real values.
  1734. 	 * @returns {Complex}
  1735. 	 */
  1736. 	erfc() {
  1737. 		return new Complex(Probability.erfc(this._re));
  1738. 	}
  1739.  
  1740. 	/**
  1741. 	 * Inverse function of Error function.
  1742. 	 * - Calculate from real values.
  1743. 	 * @returns {Complex}
  1744. 	 */
  1745. 	erfinv() {
  1746. 		return new Complex(Probability.erfinv(this._re));
  1747. 	}
  1748.  
  1749. 	/**
  1750. 	 * Inverse function of Complementary error function.
  1751. 	 * - Calculate from real values.
  1752. 	 * @returns {Complex}
  1753. 	 */
  1754. 	erfcinv() {
  1755. 		return new Complex(Probability.erfcinv(this._re));
  1756. 	}
  1757.  
  1758. 	/**
  1759. 	 * Probability density function (PDF) of normal distribution.
  1760. 	 * - Calculate from real values.
  1761. 	 * @param {KComplexInputData} [u=0.0] - Average value.
  1762. 	 * @param {KComplexInputData} [s=1.0] - Variance value.
  1763. 	 * @returns {Complex}
  1764. 	 */
  1765. 	normpdf(u, s) {
  1766. 		const u_ = u !== undefined ? Complex._toDouble(u) : 0.0;
  1767. 		const s_ = s !== undefined ? Complex._toDouble(s) : 1.0;
  1768. 		return new Complex(Probability.normpdf(this._re, u_, s_));
  1769. 	}
  1770.  
  1771. 	/**
  1772. 	 * Cumulative distribution function (CDF) of normal distribution.
  1773. 	 * - Calculate from real values.
  1774. 	 * @param {KComplexInputData} [u=0.0] - Average value.
  1775. 	 * @param {KComplexInputData} [s=1.0] - Variance value.
  1776. 	 * @returns {Complex}
  1777. 	 */
  1778. 	normcdf(u, s) {
  1779. 		const u_ = u !== undefined ? Complex._toDouble(u) : 0.0;
  1780. 		const s_ = s !== undefined ? Complex._toDouble(s) : 1.0;
  1781. 		return new Complex(Probability.normcdf(this._re, u_, s_));
  1782. 	}
  1783.  
  1784. 	/**
  1785. 	 * Inverse function of cumulative distribution function (CDF) of normal distribution.
  1786. 	 * - Calculate from real values.
  1787. 	 * @param {KComplexInputData} [u=0.0] - Average value.
  1788. 	 * @param {KComplexInputData} [s=1.0] - Variance value.
  1789. 	 * @returns {Complex}
  1790. 	 */
  1791. 	norminv(u, s) {
  1792. 		const u_ = u !== undefined ? Complex._toDouble(u) : 0.0;
  1793. 		const s_ = s !== undefined ? Complex._toDouble(s) : 1.0;
  1794. 		return new Complex(Probability.norminv(this._re, u_, s_));
  1795. 	}
  1796. 	
  1797. 	/**
  1798. 	 * Probability density function (PDF) of binomial distribution.
  1799. 	 * - Calculate from real values.
  1800. 	 * @param {KComplexInputData} n
  1801. 	 * @param {KComplexInputData} p
  1802. 	 * @returns {Complex}
  1803. 	 */
  1804. 	binopdf(n, p) {
  1805. 		const n_ = Complex._toDouble(n);
  1806. 		const p_ = Complex._toDouble(p);
  1807. 		return new Complex(Probability.binopdf(this._re, n_, p_));
  1808. 	}
  1809.  
  1810. 	/**
  1811. 	 * Cumulative distribution function (CDF) of binomial distribution.
  1812. 	 * - Calculate from real values.
  1813. 	 * @param {KComplexInputData} n
  1814. 	 * @param {KComplexInputData} p
  1815. 	 * @param {string} [tail="lower"] - lower (default) , "upper"
  1816. 	 * @returns {Complex}
  1817. 	 */
  1818. 	binocdf(n, p, tail) {
  1819. 		const n_ = Complex._toDouble(n);
  1820. 		const p_ = Complex._toDouble(p);
  1821. 		return new Complex(Probability.binocdf(this._re, n_, p_, tail));
  1822. 	}
  1823.  
  1824. 	/**
  1825. 	 * Inverse function of cumulative distribution function (CDF) of binomial distribution.
  1826. 	 * - Calculate from real values.
  1827. 	 * @param {KComplexInputData} n
  1828. 	 * @param {KComplexInputData} p
  1829. 	 * @returns {Complex}
  1830. 	 */
  1831. 	binoinv(n, p) {
  1832. 		const n_ = Complex._toDouble(n);
  1833. 		const p_ = Complex._toDouble(p);
  1834. 		return new Complex(Probability.binoinv(this._re, n_, p_));
  1835. 	}
  1836.  
  1837. 	/**
  1838. 	 * Probability density function (PDF) of Poisson distribution.
  1839. 	 * - Calculate from real values.
  1840. 	 * @param {KComplexInputData} lambda
  1841. 	 * @returns {Complex}
  1842. 	 */
  1843. 	poisspdf(lambda) {
  1844. 		const lambda_ = Complex._toDouble(lambda);
  1845. 		return new Complex(Probability.poisspdf(this._re, lambda_));
  1846. 	}
  1847.  
  1848. 	/**
  1849. 	 * Cumulative distribution function (CDF) of Poisson distribution.
  1850. 	 * - Calculate from real values.
  1851. 	 * @param {KComplexInputData} lambda
  1852. 	 * @returns {Complex}
  1853. 	 */
  1854. 	poisscdf(lambda) {
  1855. 		const lambda_ = Complex._toDouble(lambda);
  1856. 		return new Complex(Probability.poisscdf(this._re, lambda_));
  1857. 	}
  1858.  
  1859. 	/**
  1860. 	 * Inverse function of cumulative distribution function (CDF) of Poisson distribution.
  1861. 	 * - Calculate from real values.
  1862. 	 * @param {KComplexInputData} lambda
  1863. 	 * @returns {Complex}
  1864. 	 */
  1865. 	poissinv(lambda) {
  1866. 		const lambda_ = Complex._toDouble(lambda);
  1867. 		return new Complex(Probability.poissinv(this._re, lambda_));
  1868. 	}
  1869.  
  1870. 	/**
  1871. 	 * Probability density function (PDF) of Student's t-distribution.
  1872. 	 * - Calculate from real values.
  1873. 	 * @param {KComplexInputData} v - The degrees of freedom. (DF)
  1874. 	 * @returns {Complex}
  1875. 	 */
  1876. 	tpdf(v) {
  1877. 		const v_ = Complex._toDouble(v);
  1878. 		return new Complex(Probability.tpdf(this._re, v_));
  1879. 	}
  1880.  
  1881. 	/**
  1882. 	 * Cumulative distribution function (CDF) of Student's t-distribution.
  1883. 	 * - Calculate from real values.
  1884. 	 * @param {KComplexInputData} v - The degrees of freedom. (DF)
  1885. 	 * @returns {Complex}
  1886. 	 */
  1887. 	tcdf(v) {
  1888. 		const v_ = Complex._toDouble(v);
  1889. 		return new Complex(Probability.tcdf(this._re, v_));
  1890. 	}
  1891.  
  1892. 	/**
  1893. 	 * Inverse of cumulative distribution function (CDF) of Student's t-distribution.
  1894. 	 * - Calculate from real values.
  1895. 	 * @param {KComplexInputData} v - The degrees of freedom. (DF)
  1896. 	 * @returns {Complex}
  1897. 	 */
  1898. 	tinv(v) {
  1899. 		const v_ = Complex._toDouble(v);
  1900. 		return new Complex(Probability.tinv(this._re, v_));
  1901. 	}
  1902.  
  1903. 	/**
  1904. 	 * Cumulative distribution function (CDF) of Student's t-distribution that can specify tail.
  1905. 	 * - Calculate from real values.
  1906. 	 * @param {KComplexInputData} v - The degrees of freedom. (DF)
  1907. 	 * @param {KComplexInputData} tails - Tail. (1 = the one-tailed distribution, 2 =  the two-tailed distribution.)
  1908. 	 * @returns {Complex}
  1909. 	 */
  1910. 	tdist(v, tails) {
  1911. 		const v_ = Complex._toDouble(v);
  1912. 		const tails_ = Complex._toInteger(tails);
  1913. 		return new Complex(Probability.tdist(this._re, v_, tails_));
  1914. 	}
  1915.  
  1916. 	/**
  1917. 	 * Inverse of cumulative distribution function (CDF) of Student's t-distribution in two-sided test.
  1918. 	 * - Calculate from real values.
  1919. 	 * @param {KComplexInputData} v - The degrees of freedom. (DF)
  1920. 	 * @returns {Complex}
  1921. 	 */
  1922. 	tinv2(v) {
  1923. 		const v_ = Complex._toDouble(v);
  1924. 		return new Complex(Probability.tinv2(this._re, v_));
  1925. 	}
  1926.  
  1927. 	/**
  1928. 	 * Probability density function (PDF) of chi-square distribution.
  1929. 	 * - Calculate from real values.
  1930. 	 * @param {KComplexInputData} k - The degrees of freedom. (DF)
  1931. 	 * @returns {Complex}
  1932. 	 */
  1933. 	chi2pdf(k) {
  1934. 		const k_ = Complex._toDouble(k);
  1935. 		return new Complex(Probability.chi2pdf(this._re, k_));
  1936. 	}
  1937.  
  1938. 	/**
  1939. 	 * Cumulative distribution function (CDF) of chi-square distribution.
  1940. 	 * - Calculate from real values.
  1941. 	 * @param {KComplexInputData} k - The degrees of freedom. (DF)
  1942. 	 * @returns {Complex}
  1943. 	 */
  1944. 	chi2cdf(k) {
  1945. 		const k_ = Complex._toDouble(k);
  1946. 		return new Complex(Probability.chi2cdf(this._re, k_));
  1947. 	}
  1948.  
  1949. 	/**
  1950. 	 * Inverse function of cumulative distribution function (CDF) of chi-square distribution.
  1951. 	 * - Calculate from real values.
  1952. 	 * @param {KComplexInputData} k - The degrees of freedom. (DF)
  1953. 	 * @returns {Complex}
  1954. 	 */
  1955. 	chi2inv(k) {
  1956. 		const k_ = Complex._toDouble(k);
  1957. 		return new Complex(Probability.chi2inv(this._re, k_));
  1958. 	}
  1959.  
  1960. 	/**
  1961. 	 * Probability density function (PDF) of F-distribution.
  1962. 	 * - Calculate from real values.
  1963. 	 * @param {KComplexInputData} d1 - The degree of freedom of the molecules.
  1964. 	 * @param {KComplexInputData} d2 - The degree of freedom of the denominator
  1965. 	 * @returns {Complex}
  1966. 	 */
  1967. 	fpdf(d1, d2) {
  1968. 		const d1_ = Complex._toDouble(d1);
  1969. 		const d2_ = Complex._toDouble(d2);
  1970. 		return new Complex(Probability.fpdf(this._re, d1_, d2_));
  1971. 	}
  1972.  
  1973. 	/**
  1974. 	 * Cumulative distribution function (CDF) of F-distribution.
  1975. 	 * - Calculate from real values.
  1976. 	 * @param {KComplexInputData} d1 - The degree of freedom of the molecules.
  1977. 	 * @param {KComplexInputData} d2 - The degree of freedom of the denominator
  1978. 	 * @returns {Complex}
  1979. 	 */
  1980. 	fcdf(d1, d2) {
  1981. 		const d1_ = Complex._toDouble(d1);
  1982. 		const d2_ = Complex._toDouble(d2);
  1983. 		return new Complex(Probability.fcdf(this._re, d1_, d2_));
  1984. 	}
  1985.  
  1986. 	/**
  1987. 	 * Inverse function of cumulative distribution function (CDF) of F-distribution.
  1988. 	 * - Calculate from real values.
  1989. 	 * @param {KComplexInputData} d1 - The degree of freedom of the molecules.
  1990. 	 * @param {KComplexInputData} d2 - The degree of freedom of the denominator
  1991. 	 * @returns {Complex}
  1992. 	 */
  1993. 	finv(d1, d2) {
  1994. 		const d1_ = Complex._toDouble(d1);
  1995. 		const d2_ = Complex._toDouble(d2);
  1996. 		return new Complex(Probability.finv(this._re, d1_, d2_));
  1997. 	}
  1998.  
  1999. 	// ----------------------
  2000. 	// ビット演算系
  2001. 	// ----------------------
  2002. 	
  2003. 	/**
  2004. 	 * Logical AND.
  2005. 	 * - Calculated as an integer.
  2006. 	 * @param {KComplexInputData} number 
  2007. 	 * @returns {Complex} A & B
  2008. 	 */
  2009. 	and(number) {
  2010. 		const n_src = Math.round(this.real);
  2011. 		const n_tgt = Math.round(Complex._toDouble(number));
  2012. 		return new Complex(n_src & n_tgt);
  2013. 	}
  2014.  
  2015. 	/**
  2016. 	 * Logical OR.
  2017. 	 * - Calculated as an integer.
  2018. 	 * @param {KComplexInputData} number 
  2019. 	 * @returns {Complex} A | B
  2020. 	 */
  2021. 	or(number) {
  2022. 		const n_src = Math.round(this.real);
  2023. 		const n_tgt = Math.round(Complex._toDouble(number));
  2024. 		return new Complex(n_src | n_tgt);
  2025. 	}
  2026.  
  2027. 	/**
  2028. 	 * Logical Exclusive-OR.
  2029. 	 * - Calculated as an integer.
  2030. 	 * @param {KComplexInputData} number 
  2031. 	 * @returns {Complex} A ^ B
  2032. 	 */
  2033. 	xor(number) {
  2034. 		const n_src = Math.round(this.real);
  2035. 		const n_tgt = Math.round(Complex._toDouble(number));
  2036. 		return new Complex(n_src ^ n_tgt);
  2037. 	}
  2038.  
  2039. 	/**
  2040. 	 * Logical Not. (mutable)
  2041. 	 * - Calculated as an integer.
  2042. 	 * @returns {Complex} !A
  2043. 	 */
  2044. 	not() {
  2045. 		const n_src = Math.round(this.real);
  2046. 		return new Complex(!n_src);
  2047. 	}
  2048. 	
  2049. 	/**
  2050. 	 * this << n
  2051. 	 * - Calculated as an integer.
  2052. 	 * @param {KComplexInputData} n
  2053. 	 * @returns {Complex} A << n
  2054. 	 */
  2055. 	shift(n) {
  2056. 		const src = Math.round(this.real);
  2057. 		const number = Math.round(Complex._toDouble(n));
  2058. 		return new Complex(src << number);
  2059. 	}
  2060.  
  2061. 	// ----------------------
  2062. 	// factor
  2063. 	// ----------------------
  2064.  
  2065. 	/**
  2066. 	 * Factorization.
  2067. 	 * - Calculated as an integer.
  2068. 	 * - Calculate up to `9007199254740991`.
  2069. 	 * @returns {Complex[]} factor
  2070. 	 */
  2071. 	factor() {
  2072. 		const x = this.round().toBigInteger().factor();
  2073. 		const y = [];
  2074. 		for(let i = 0; i < x.length; i++) {
  2075. 			y.push(new Complex(x[i]));
  2076. 		}
  2077. 		return y;
  2078. 	}
  2079.  
  2080. 	// ----------------------
  2081. 	// gcd, lcm
  2082. 	// ----------------------
  2083. 	
  2084. 	/**
  2085. 	 * Euclidean algorithm.
  2086. 	 * - Calculated as an integer.
  2087. 	 * @param {KComplexInputData} number 
  2088. 	 * @returns {Complex} gcd(x, y)
  2089. 	 */
  2090. 	gcd(number) {
  2091. 		const x = Math.round(this.real);
  2092. 		const y = Math.round(Complex._toDouble(number));
  2093. 		const result = new BigInteger(x).gcd(y);
  2094. 		return new Complex(result);
  2095. 	}
  2096.  
  2097. 	/**
  2098. 	 * Extended Euclidean algorithm.
  2099. 	 * - Calculated as an integer.
  2100. 	 * @param {KComplexInputData} number 
  2101. 	 * @returns {Array<Complex>} [a, b, gcd(x, y)], Result of calculating a*x + b*y = gcd(x, y).
  2102. 	 */
  2103. 	extgcd(number) {
  2104. 		const x = Math.round(this.real);
  2105. 		const y = Math.round(Complex._toDouble(number));
  2106. 		const result = new BigInteger(x).extgcd(y);
  2107. 		return [new Complex(result[0]), new Complex(result[1]), new Complex(result[2])];
  2108. 	}
  2109.  
  2110. 	/**
  2111. 	 * Least common multiple.
  2112. 	 * - Calculated as an integer.
  2113. 	 * @param {KComplexInputData} number 
  2114. 	 * @returns {Complex} lcm(x, y)
  2115. 	 */
  2116. 	lcm(number) {
  2117. 		const x = Math.round(this.real);
  2118. 		const y = Math.round(Complex._toDouble(number));
  2119. 		const result = new BigInteger(x).lcm(y);
  2120. 		return new Complex(result);
  2121. 	}
  2122.  
  2123. 	// ----------------------
  2124. 	// mod
  2125. 	// ----------------------
  2126.  
  2127. 	/**
  2128. 	 * Modular exponentiation.
  2129. 	 * - Calculated as an integer.
  2130. 	 * @param {KComplexInputData} exponent
  2131. 	 * @param {KComplexInputData} m 
  2132. 	 * @returns {Complex} A^B mod m
  2133. 	 */
  2134. 	modPow(exponent, m) {
  2135. 		const A = Math.round(this.real);
  2136. 		const B = Math.round(Complex._toDouble(exponent));
  2137. 		const m_ = Math.round(Complex._toDouble(m));
  2138. 		const result = new BigInteger(A).modPow(B, m_);
  2139. 		return new Complex(result);
  2140. 	}
  2141.  
  2142. 	/**
  2143. 	 * Modular multiplicative inverse.
  2144. 	 * - Calculated as an integer.
  2145. 	 * @param {KComplexInputData} m
  2146. 	 * @returns {Complex} A^(-1) mod m
  2147. 	 */
  2148. 	modInverse(m) {
  2149. 		const A = Math.round(this.real);
  2150. 		const m_ = Math.round(Complex._toDouble(m));
  2151. 		const result = new BigInteger(A).modInverse(m_);
  2152. 		return new Complex(result);
  2153. 	}
  2154. 	
  2155. 	// ----------------------
  2156. 	// その他の演算
  2157. 	// ----------------------
  2158. 	
  2159. 	/**
  2160. 	 * Multiply a multiple of ten.
  2161. 	 * @param {KComplexInputData} n
  2162. 	 * @returns {Complex} x * 10^n
  2163. 	 */
  2164. 	scaleByPowerOfTen(n) {
  2165. 		return this.mul(Complex.TEN.pow(n));
  2166. 	}
  2167.  
  2168. 	// ----------------------
  2169. 	// 素数
  2170. 	// ----------------------
  2171. 	
  2172. 	/**
  2173. 	 * Return true if the value is prime number.
  2174. 	 * - Calculated as an integer.
  2175. 	 * - Calculate up to `9007199254740991`.
  2176. 	 * @returns {boolean} - If the calculation range is exceeded, null is returned.
  2177. 	 */
  2178. 	isPrime() {
  2179. 		const src = new BigInteger(Math.round(this.real));
  2180. 		return src.isPrime();
  2181. 	}
  2182. 	
  2183. 	/**
  2184. 	 * Return true if the value is prime number by Miller-Labin prime number determination method.
  2185. 	 * 
  2186. 	 * Attention : it takes a very long time to process.
  2187. 	 * - Calculated as an integer.
  2188. 	 * @param {KComplexInputData} [certainty=100] - Repeat count (prime precision).
  2189. 	 * @returns {boolean}
  2190. 	 */
  2191. 	isProbablePrime(certainty) {
  2192. 		const src = new BigInteger(Math.round(this.real));
  2193. 		return src.isProbablePrime(certainty !== undefined ? Math.round(Complex._toDouble(certainty)) : undefined);
  2194. 	}
  2195.  
  2196. 	/**
  2197. 	 * Next prime.
  2198. 	 * @param {KComplexInputData} [certainty=100] - Repeat count (prime precision).
  2199. 	 * @param {KComplexInputData} [search_max=100000] - Search range of next prime.
  2200. 	 * @returns {Complex}
  2201. 	 */
  2202. 	nextProbablePrime(certainty, search_max) {
  2203. 		const src = new BigInteger(Math.round(this.real));
  2204. 		const p1 = certainty !== undefined ? Math.round(Complex._toDouble(certainty)) : undefined;
  2205. 		const p2 = search_max !== undefined ? Math.round(Complex._toDouble(search_max)) : undefined;
  2206. 		return new Complex(src.nextProbablePrime(p1, p2));
  2207. 	}
  2208.  
  2209. 	// ----------------------
  2210. 	// 定数
  2211. 	// ----------------------
  2212. 	
  2213. 	/**
  2214. 	 * 1
  2215. 	 * @returns {Complex} 1
  2216. 	 */
  2217. 	static get ONE() {
  2218. 		return DEFINE.ONE;
  2219. 	}
  2220. 	
  2221. 	/**
  2222. 	 * 2
  2223. 	 * @returns {Complex} 2
  2224. 	 */
  2225. 	static get TWO() {
  2226. 		return DEFINE.TWO;
  2227. 	}
  2228. 	
  2229. 	/**
  2230. 	 * 10
  2231. 	 * @returns {Complex} 10
  2232. 	 */
  2233. 	static get TEN() {
  2234. 		return DEFINE.TEN;
  2235. 	}
  2236. 	
  2237. 	/**
  2238. 	 * 0
  2239. 	 * @returns {Complex} 0
  2240. 	 */
  2241. 	static get ZERO() {
  2242. 		return DEFINE.ZERO;
  2243. 	}
  2244.  
  2245. 	/**
  2246. 	 * -1
  2247. 	 * @returns {Complex} -1
  2248. 	 */
  2249. 	static get MINUS_ONE() {
  2250. 		return DEFINE.MINUS_ONE;
  2251. 	}
  2252.  
  2253. 	/**
  2254. 	 * i, j
  2255. 	 * @returns {Complex} i
  2256. 	 */
  2257. 	static get I() {
  2258. 		return DEFINE.I;
  2259. 	}
  2260.  
  2261. 	/**
  2262. 	 * - i, - j
  2263. 	 * @returns {Complex} - i
  2264. 	 */
  2265. 	static get MINUS_I() {
  2266. 		return DEFINE.MINUS_I;
  2267. 	}
  2268.  
  2269. 	/**
  2270. 	 * PI.
  2271. 	 * @returns {Complex} 3.14...
  2272. 	 */
  2273. 	static get PI() {
  2274. 		return DEFINE.PI;
  2275. 	}
  2276.  
  2277. 	/**
  2278. 	 * 0.25 * PI.
  2279. 	 * @returns {Complex} 0.78...
  2280. 	 */
  2281. 	static get QUARTER_PI() {
  2282. 		return DEFINE.QUARTER_PI;
  2283. 	}
  2284.  
  2285. 	/**
  2286. 	 * 0.5 * PI.
  2287. 	 * @returns {Complex} 1.57...
  2288. 	 */
  2289. 	static get HALF_PI() {
  2290. 		return DEFINE.HALF_PI;
  2291. 	}
  2292.  
  2293. 	/**
  2294. 	 * 2 * PI.
  2295. 	 * @returns {Complex} 6.28...
  2296. 	 */
  2297. 	static get TWO_PI() {
  2298. 		return DEFINE.TWO_PI;
  2299. 	}
  2300.  
  2301. 	/**
  2302. 	 * E, Napier's constant.
  2303. 	 * @returns {Complex} 2.71...
  2304. 	 */
  2305. 	static get E() {
  2306. 		return DEFINE.E;
  2307. 	}
  2308.  
  2309. 	/**
  2310. 	 * log_e(2)
  2311. 	 * @returns {Complex} ln(2)
  2312. 	 */
  2313. 	static get LN2() {
  2314. 		return DEFINE.LN2;
  2315. 	}
  2316.  
  2317. 	/**
  2318. 	 * log_e(10)
  2319. 	 * @returns {Complex} ln(10)
  2320. 	 */
  2321. 	static get LN10() {
  2322. 		return DEFINE.LN10;
  2323. 	}
  2324.  
  2325. 	/**
  2326. 	 * log_2(e)
  2327. 	 * @returns {Complex} log_2(e)
  2328. 	 */
  2329. 	static get LOG2E() {
  2330. 		return DEFINE.LOG2E;
  2331. 	}
  2332. 	
  2333. 	/**
  2334. 	 * log_10(e)
  2335. 	 * @returns {Complex} log_10(e)
  2336. 	 */
  2337. 	static get LOG10E() {
  2338. 		return DEFINE.LOG10E;
  2339. 	}
  2340. 	
  2341. 	/**
  2342. 	 * sqrt(2)
  2343. 	 * @returns {Complex} sqrt(2)
  2344. 	 */
  2345. 	static get SQRT2() {
  2346. 		return DEFINE.SQRT2;
  2347. 	}
  2348. 	
  2349. 	/**
  2350. 	 * sqrt(0.5)
  2351. 	 * @returns {Complex} sqrt(0.5)
  2352. 	 */
  2353. 	static get SQRT1_2() {
  2354. 		return DEFINE.SQRT1_2;
  2355. 	}
  2356. 	
  2357. 	/**
  2358. 	 * 0.5
  2359. 	 * @returns {Complex} 0.5
  2360. 	 */
  2361. 	static get HALF() {
  2362. 		return DEFINE.HALF;
  2363. 	}
  2364.  
  2365. 	/**
  2366. 	 * Positive infinity.
  2367. 	 * @returns {Complex} Infinity
  2368. 	 */
  2369. 	static get POSITIVE_INFINITY() {
  2370. 		return DEFINE.POSITIVE_INFINITY;
  2371. 	}
  2372. 	
  2373. 	/**
  2374. 	 * Negative Infinity.
  2375. 	 * @returns {Complex} -Infinity
  2376. 	 */
  2377. 	static get NEGATIVE_INFINITY() {
  2378. 		return DEFINE.NEGATIVE_INFINITY;
  2379. 	}
  2380.  
  2381. 	/**
  2382. 	 * Not a Number.
  2383. 	 * @returns {Complex} NaN
  2384. 	 */
  2385. 	static get NaN() {
  2386. 		return DEFINE.NaN;
  2387. 	}
  2388.  
  2389. 	// ----------------------
  2390. 	// 互換性
  2391. 	// ----------------------
  2392. 	
  2393. 	/**
  2394. 	 * The positive or negative sign of this number.
  2395. 	 * - +1 if positive, -1 if negative, 0 if 0.
  2396. 	 * @returns {Complex}
  2397. 	 */
  2398. 	signum() {
  2399. 		return this.sign();
  2400. 	}
  2401.  
  2402. 	/**
  2403. 	 * Subtract.
  2404. 	 * @param {KComplexInputData} number
  2405. 	 * @returns {Complex} A - B
  2406. 	 */
  2407. 	subtract(number) {
  2408. 		return this.sub(number);
  2409. 	}
  2410.  
  2411. 	/**
  2412. 	 * Multiply.
  2413. 	 * @param {KComplexInputData} number
  2414. 	 * @returns {Complex} A * B
  2415. 	 */
  2416. 	multiply(number) {
  2417. 		return this.mul(number);
  2418. 	}
  2419.  
  2420. 	/**
  2421. 	 * Divide.
  2422. 	 * @param {KComplexInputData} number
  2423. 	 * @returns {Complex} fix(A / B)
  2424. 	 */
  2425. 	divide(number) {
  2426. 		return this.div(number);
  2427. 	}
  2428.  
  2429. 	/**
  2430. 	 * Remainder of division.
  2431. 	 * - Result has same sign as the Dividend.
  2432. 	 * @param {KComplexInputData} number
  2433. 	 * @returns {Complex} A % B
  2434. 	 */
  2435. 	remainder(number) {
  2436. 		return this.rem(number);
  2437. 	}
  2438. 	
  2439. 	/**
  2440. 	 * To integer rounded down to the nearest.
  2441. 	 * @returns {Complex} fix(A), trunc(A)
  2442. 	 */
  2443. 	trunc() {
  2444. 		return this.fix();
  2445. 	}
  2446. 	
  2447. }
  2448.  
  2449. /**
  2450.  * Collection of constant values used in the class.
  2451.  * @ignore
  2452.  */
  2453. const DEFINE = {
  2454.  
  2455. 	/**
  2456. 	 * 0
  2457. 	 */
  2458. 	ZERO : new Complex(0),
  2459.  
  2460. 	/**
  2461. 	 * 1
  2462. 	 */
  2463. 	ONE : new Complex(1),
  2464.  
  2465. 	/**
  2466. 	 * 2
  2467. 	 */
  2468. 	TWO : new Complex(2),
  2469.  
  2470. 	/**
  2471. 	 * 10
  2472. 	 */
  2473. 	TEN : new Complex(10),
  2474.  
  2475. 	/**
  2476. 	 * -1
  2477. 	 */
  2478. 	MINUS_ONE : new Complex(-1),
  2479.  
  2480. 	/**
  2481. 	 * i, j
  2482. 	 */
  2483. 	I : new Complex([0, 1]),
  2484.  
  2485. 	/**
  2486. 	 * - i, - j
  2487. 	 */
  2488. 	MINUS_I : new Complex([0, -1]),
  2489.  
  2490. 	/**
  2491. 	 * PI.
  2492. 	 */
  2493. 	PI : new Complex(Math.PI),
  2494.  
  2495. 	/**
  2496. 	 * 0.25 * PI.
  2497. 	 */
  2498. 	QUARTER_PI : new Complex(0.25 * Math.PI),
  2499.  
  2500. 	/**
  2501. 	 * 0.5 * PI.
  2502. 	 */
  2503. 	HALF_PI : new Complex(0.5 * Math.PI),
  2504.  
  2505. 	/**
  2506. 	 * 2 * PI.
  2507. 	 */
  2508. 	TWO_PI : new Complex(2.0 * Math.PI),
  2509.  
  2510. 	/**
  2511. 	 * E, Napier's constant.
  2512. 	 */
  2513. 	E : new Complex(Math.E),
  2514.  
  2515. 	/**
  2516. 	 * log_e(2)
  2517. 	 */
  2518. 	LN2 : new Complex(Math.LN2),
  2519.  
  2520. 	/**
  2521. 	 * log_e(10)
  2522. 	 */
  2523. 	LN10 : new Complex(Math.LN10),
  2524.  
  2525. 	/**
  2526. 	 * log_2(e)
  2527. 	 */
  2528. 	LOG2E : new Complex(Math.LOG2E),
  2529.  
  2530. 	/**
  2531. 	 * log_10(e)
  2532. 	 */
  2533. 	LOG10E : new Complex(Math.LOG10E),
  2534.  
  2535. 	/**
  2536. 	 * sqrt(2)
  2537. 	 */
  2538. 	SQRT2 : new Complex(Math.SQRT2),
  2539.  
  2540. 	/**
  2541. 	 * sqrt(0.5)
  2542. 	 */
  2543. 	SQRT1_2 : new Complex(Math.SQRT1_2),
  2544.  
  2545. 	/**
  2546. 	 * 0.5
  2547. 	 */
  2548. 	HALF : new Complex(0.5),
  2549.  
  2550. 	/**
  2551. 	 * Positive infinity.
  2552. 	 */
  2553. 	POSITIVE_INFINITY : new Complex(Number.POSITIVE_INFINITY),
  2554.  
  2555. 	/**
  2556. 	 * Negative Infinity.
  2557. 	 */
  2558. 	NEGATIVE_INFINITY : new Complex(Number.NEGATIVE_INFINITY),
  2559.  
  2560. 	/**
  2561. 	 * Not a Number.
  2562. 	 */
  2563. 	NaN : new Complex(Number.NaN)
  2564. };
  2565.