├── README.md
├── migrations
    ├── 1_initial_migration.js
    └── 1_deploy_contracts.js
├── test
    ├── FixidityLib.js
    ├── utils.js
    ├── LogarithmLib.js
    └── ExponentLib.js
├── contracts
    ├── Migrations.sol
    ├── TestContract.sol
    ├── ExponentLib.sol
    ├── LogarithmLib.sol
    └── FixidityLib.sol
├── truffle.js
├── truffle-config.js
├── package.json
├── .gitignore
└── LICENSE


/README.md:
--------------------------------------------------------------------------------
1 | # fixidity
2 | A fixed decimal precision math library for Solidity
3 | 


--------------------------------------------------------------------------------
/migrations/1_initial_migration.js:
--------------------------------------------------------------------------------
1 | var Migrations = artifacts.require("./Migrations.sol");
2 | 
3 | module.exports = function(deployer) {
4 |   deployer.deploy(Migrations);
5 | };
6 | 


--------------------------------------------------------------------------------
/test/FixidityLib.js:
--------------------------------------------------------------------------------
 1 | var utils = require('./utils');
 2 | 
 3 | describe('FixidityLib.add', () => {
 4 | 	var data = [
 5 | 		[ [3, 4], 7000 ],
 6 | 		[ [3, -4], -1000 ],
 7 | 		[ [-3, 4], 1000 ],
 8 | 		[ [3.123, 4.789], 7912 ]
 9 | 	];
10 | 	utils.testArray('', data, 3, 3, (instance, t) => {
11 | 		return instance.add.call(t[0], t[1]);
12 | 	});
13 | });
14 | 


--------------------------------------------------------------------------------
/contracts/Migrations.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.23;
 2 | 
 3 | contract Migrations {
 4 |   address public owner;
 5 |   uint public last_completed_migration;
 6 | 
 7 |   constructor() public {
 8 |     owner = msg.sender;
 9 |   }
10 | 
11 |   modifier restricted() {
12 |     if (msg.sender == owner) _;
13 |   }
14 | 
15 |   function setCompleted(uint completed) public restricted {
16 |     last_completed_migration = completed;
17 |   }
18 | 
19 |   function upgrade(address new_address) public restricted {
20 |     Migrations upgraded = Migrations(new_address);
21 |     upgraded.setCompleted(last_completed_migration);
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/truffle.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * NB: since truffle-hdwallet-provider 0.0.5 you must wrap HDWallet providers in a 
 3 |  * function when declaring them. Failure to do so will cause commands to hang. ex:
 4 |  * ```
 5 |  * mainnet: {
 6 |  *     provider: function() { 
 7 |  *       return new HDWalletProvider(mnemonic, 'https://mainnet.infura.io/<infura-key>') 
 8 |  *     },
 9 |  *     network_id: '1',
10 |  *     gas: 4500000,
11 |  *     gasPrice: 10000000000,
12 |  *   },
13 |  */
14 | 
15 | module.exports = {
16 |   // See <http://truffleframework.com/docs/advanced/configuration>
17 |   // to customize your Truffle configuration!
18 | };
19 | 


--------------------------------------------------------------------------------
/truffle-config.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * NB: since truffle-hdwallet-provider 0.0.5 you must wrap HDWallet providers in a 
 3 |  * function when declaring them. Failure to do so will cause commands to hang. ex:
 4 |  * ```
 5 |  * mainnet: {
 6 |  *     provider: function() { 
 7 |  *       return new HDWalletProvider(mnemonic, 'https://mainnet.infura.io/<infura-key>') 
 8 |  *     },
 9 |  *     network_id: '1',
10 |  *     gas: 4500000,
11 |  *     gasPrice: 10000000000,
12 |  *   },
13 |  */
14 | 
15 | module.exports = {
16 |   // See <http://truffleframework.com/docs/advanced/configuration>
17 |   // to customize your Truffle configuration!
18 | };
19 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "fixidity",
 3 |   "version": "1.0.0",
 4 |   "description": "Fixed precision decimal math library for Solidity",
 5 |   "main": "truffle-config.js",
 6 |   "directories": {
 7 |     "test": "test"
 8 |   },
 9 |   "scripts": {
10 |     "test": "test"
11 |   },
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "git+https://github.com/extraterrestrial-tech/fixidity.git"
15 |   },
16 |   "author": "gadiguy@gmail.com",
17 |   "license": "Apache-2.0",
18 |   "bugs": {
19 |     "url": "https://github.com/extraterrestrial-tech/fixidity/issues"
20 |   },
21 |   "homepage": "https://github.com/extraterrestrial-tech/fixidity#readme"
22 | }
23 | 


--------------------------------------------------------------------------------
/migrations/1_deploy_contracts.js:
--------------------------------------------------------------------------------
 1 | var FixidityLib = artifacts.require("FixidityLib");
 2 | var LogarithmLib = artifacts.require("LogarithmLib");
 3 | var ExponentLib = artifacts.require("ExponentLib");
 4 | var TestContract = artifacts.require("TestContract");
 5 | 
 6 | module.exports = function(deployer) {
 7 | 
 8 | 	deployer.deploy(FixidityLib)
 9 | 	.then(() => deployer.link(FixidityLib, LogarithmLib))
10 | 	.then(() => deployer.deploy(LogarithmLib))
11 | 	.then(() => deployer.link(LogarithmLib, ExponentLib))
12 | 	.then(() => deployer.link(FixidityLib, ExponentLib))
13 | 	.then(() => deployer.deploy(ExponentLib))
14 | 	.then(() => {
15 |     	deployer.link(FixidityLib, TestContract);
16 |     	deployer.link(LogarithmLib, TestContract);
17 |     	deployer.link(ExponentLib, TestContract);
18 |     	return deployer.deploy(TestContract);
19 | 	});
20 | };
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | 
 8 | # Runtime data
 9 | pids
10 | *.pid
11 | *.seed
12 | *.pid.lock
13 | 
14 | # Directory for instrumented libs generated by jscoverage/JSCover
15 | lib-cov
16 | 
17 | # Coverage directory used by tools like istanbul
18 | coverage
19 | 
20 | # nyc test coverage
21 | .nyc_output
22 | 
23 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
24 | .grunt
25 | 
26 | # Bower dependency directory (https://bower.io/)
27 | bower_components
28 | 
29 | # node-waf configuration
30 | .lock-wscript
31 | 
32 | # Compiled binary addons (https://nodejs.org/api/addons.html)
33 | build/Release
34 | 
35 | # Dependency directories
36 | node_modules/
37 | jspm_packages/
38 | 
39 | # TypeScript v1 declaration files
40 | typings/
41 | 
42 | # Optional npm cache directory
43 | .npm
44 | 
45 | # Optional eslint cache
46 | .eslintcache
47 | 
48 | # Optional REPL history
49 | .node_repl_history
50 | 
51 | # Output of 'npm pack'
52 | *.tgz
53 | 
54 | # Yarn Integrity file
55 | .yarn-integrity
56 | 
57 | # dotenv environment variables file
58 | .env
59 | 
60 | # next.js build output
61 | .next
62 | 


--------------------------------------------------------------------------------
/test/utils.js:
--------------------------------------------------------------------------------
 1 | 
 2 | function forInstance(cb, digits) {
 3 | 	return artifacts.require("TestContract").deployed()
 4 | 		.then(instance => instance.init(digits).then(() => cb(instance)));
 5 | }
 6 | 
 7 | function expectToThrow(cb) {
 8 | 	var flag = false;
 9 | 	return cb()
10 | 	.catch(() => { flag = true; return assert(true); } )
11 | 	.then(() => { if(!flag) return assert(false); });
12 | }
13 | 
14 | function toFixed(a, digits) {
15 | 	return a * Math.pow(10, digits);
16 | }
17 | 
18 | function compareFixedNumbers(a, b, digits, precision) {
19 | 	var t = Math.pow(10, (digits - precision));
20 | 	a = Math.round(a / t);
21 | 	b = Math.round(b / t);
22 | 	assert.equal(a, b);
23 | }
24 | 
25 | function testArray(msg, data, digits, precision, cb) {
26 | 	var pa = data.map(t => {
27 | 		if(typeof(t[0]) == 'number') t[0] = toFixed(t[0], digits);
28 | 		else if(Array.isArray(t[0])) t[0] = t[0].map(tt => toFixed(tt, digits));
29 | 		it(msg + t[0], () => {
30 | 			return artifacts.require("TestContract").deployed()
31 | 			.then(instance => {
32 | 				return instance.init(digits)
33 | 				.then(() => cb(instance, t[0]))
34 | 				.then(result => compareFixedNumbers(result.valueOf(), t[1], digits, precision));
35 | 			});
36 | 		});
37 | 	});
38 | 	return Promise.all(pa);
39 | };
40 | 
41 | module.exports = {
42 | 	forInstance, expectToThrow, toFixed, testArray
43 | }
44 | 


--------------------------------------------------------------------------------
/test/LogarithmLib.js:
--------------------------------------------------------------------------------
 1 | var utils = require('./utils');
 2 | 
 3 | describe('LogarithmLib.log_e', () => {
 4 | 	var data = [
 5 | 	//                 .1234567890123456
 6 | 		[ 1, 						   0 ],
 7 | 		[ 2, 			6931471805599453 ],
 8 | 		[ 1.1, 			 953101798043249 ],
 9 | 		[ 1.2, 			1823215567939546 ],
10 | 		[ 1.48763547, 	3971879265597280 ],
11 | 		[ 0.000001,  -138155105579642741 ],
12 | 		[ 0.1, 		  -23025850929940457 ],
13 | 		[ 0.2, 		  -16094379124341004 ],
14 | 		[ 0.4,	 	   -9162907318741551 ],
15 | 		[ 0.6, 		   -5108256237659907 ],
16 | 		[ 0.7, 		   -3566749439387324 ],
17 | 		[ 0.8, 		   -2231435513142098 ],
18 | 		[ 1.9, 		    6418538861723948 ],
19 | 		[ 1.99, 		6881346387364010 ],
20 | 		[ 1.9999, 		6930971793099036 ],
21 | 		[ 1.99999999, 	6931471755599453 ],
22 | 		[ 2, 			6931471805599453 ],
23 | 		[ 57, 		   40430512678345502 ],
24 | 		[ 148, 		   49972122737641151 ],
25 | 		[ 19283765,   167747741081649877 ]
26 | 	];
27 | 	utils.testArray('', data, 16, 14, (instance, t) => {
28 | 		return instance.log_e.call(t);
29 | 	});
30 | });
31 | 
32 | describe('LogarithmLib.log_any', () => {
33 | 	var data = [
34 | 	//                 		 			.1234567890123456
35 | 		[ [ 2, 2.123 ],		 			10861043712432906 ],
36 | 		[ [ 1.1, 2.1 ],		 			77844501631683068 ],
37 | 		[ [ 10.8876, 2.8777655443 ], 	 4427053451662782 ],
38 | 		[ [ 0.00002, 0.0004 ],			 7231244305744783 ]
39 | 	];
40 | 	utils.testArray('', data, 16, 12, (instance, t) => {
41 | 		return instance.log_any.call(t[0], t[1]);
42 | 	});
43 | });
44 | 


--------------------------------------------------------------------------------
/contracts/TestContract.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.24;
 2 | 
 3 | import "./FixidityLib.sol";
 4 | import "./ExponentLib.sol";
 5 | import "./LogarithmLib.sol";
 6 | 
 7 | contract TestContract {
 8 | 	using FixidityLib for FixidityLib.Fixidity;
 9 | 	using ExponentLib for FixidityLib.Fixidity;
10 | 	using LogarithmLib for FixidityLib.Fixidity;
11 | 
12 | 	FixidityLib.Fixidity public fixidity;
13 | 
14 | 	function init(uint8 digits) public {
15 | 		fixidity.init(digits);
16 | 	}
17 | 
18 | 	function add(int256 a, int256 b) public view returns (int256) {
19 | 		return fixidity.add(a, b);
20 | 	}
21 | 
22 | 	function subtract(int256 a, int256 b) public view returns (int256) {
23 | 		return fixidity.subtract(a, b);
24 | 	}
25 | 
26 | 	function divide(int256 a, int256 b) public view returns (int256) {
27 | 		return fixidity.divide(a, b);
28 | 	}
29 | 
30 | 	function multiply(int256 a, int256 b) public view returns (int256) {
31 | 		return fixidity.multiply(a, b);
32 | 	}
33 | 
34 | 	function log_e(int256 input) public view returns (int256) {
35 | 		return fixidity.log_e(input);
36 | 	}
37 | 
38 | 	function log_any(int256 base, int256 v) public view returns (int256) {
39 | 		return fixidity.log_any(base, v);
40 | 	}
41 | 
42 | 	function power_e(int256 input) public view returns (int256) {
43 | 		return fixidity.power_e(input);
44 | 	}
45 | 
46 | 	function power_any(int256 a, int256 b) public view returns (int256) {
47 | 		return fixidity.power_any(a, b);
48 | 	}
49 | 
50 | 	function root_any(int256 a, int256 b) public view returns (int256) {
51 | 		return fixidity.root_any(a, b);
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/contracts/ExponentLib.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.24;
 2 | 
 3 | import "./FixidityLib.sol";
 4 | import "./LogarithmLib.sol";
 5 | 
 6 | library ExponentLib {
 7 | 
 8 |     using FixidityLib for FixidityLib.Fixidity;
 9 |     using LogarithmLib for FixidityLib.Fixidity;
10 | 
11 |     function power_e(FixidityLib.Fixidity storage fixidity, int256 x) public view returns (int256) {
12 |         assert(x < 172 * fixidity.fixed_1);
13 |     	int256 r = fixidity.fixed_1;
14 |         while(x >= 10 * fixidity.fixed_1) {
15 |             x -= 10 * fixidity.fixed_1;
16 |             r = fixidity.multiply(r, fixidity.fixed_exp_10);
17 |         }
18 |         if(x == fixidity.fixed_1) {
19 |             return fixidity.multiply(r, fixidity.fixed_e);
20 |         } else if(x == 0) {
21 |             return r;
22 |         }
23 |         int256 tr = 100 * fixidity.fixed_1;
24 |         int256 d = tr;
25 |         for(uint8 i = 1; i <= 2 * fixidity.digits; i++) {
26 |             d = (d * x) / (fixidity.fixed_1 * i);
27 |             tr += d;
28 |         }
29 |     	return fixidity.trunc_digits(fixidity.multiply(tr, r), 2);
30 |     }
31 | 
32 |     function power_any(FixidityLib.Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
33 |         return power_e(fixidity, fixidity.multiply(fixidity.log_e(a), b));
34 |     }
35 | 
36 |     function root_any(FixidityLib.Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
37 |         return power_any(fixidity, a, fixidity.reciprocal(b));
38 |     }
39 | 
40 |     function root_n(FixidityLib.Fixidity storage fixidity, int256 a, uint8 n) public view returns (int256) {
41 |         return power_e(fixidity, fixidity.divide(fixidity.log_e(a), fixidity.fixed_1 * n));
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/test/ExponentLib.js:
--------------------------------------------------------------------------------
 1 | var utils = require('./utils');
 2 | 
 3 | describe('ExponentLib.power_e', () => {
 4 | 	//                      .1234567890123456
 5 | 	var data = [
 6 | 		[ 1, 				27182818284590452 ],
 7 | 		[ 2, 				73890560989306502 ],
 8 | 		[ 1.1, 				30041660239464331 ],
 9 | 		[ 1.2, 				33201169227365475 ],
10 | 		[ 1.48763547, 		44266162676706513 ],
11 | 		[ 0.000001, 		10000010000005000 ],
12 | 		[ 0.1, 				11051709180756476 ],
13 | 		[ 0.2, 				12214027581601698 ],
14 | 		[ 0.4, 				14918246976412703 ],
15 | 		[ 0.6, 				18221188003905090 ],
16 | 		[ 0.7, 				20137527074704765 ],
17 | 		[ 0.8, 				22255409284924676 ],
18 | 		[ 1.9, 				66858944422792694 ],
19 | 		[ 1.99, 			73155337623095665 ],
20 | 		[ 1.9999, 			73883172302648062 ],
21 | 		[ 10, 		    220264657948067165170 ],
22 | 		[ 21.785,  28913807698291736761599108 ]
23 | 	];
24 | 	utils.testArray('', data, 16, 16, (instance, t) => {
25 | 		return instance.power_e.call(t);
26 | 	});
27 | });
28 | 
29 | describe('ExponentLib.power_any', () => {
30 | 	//                      			.123456789012
31 | 	var data = [
32 | 		[ [ 2, 3 ], 					8000000000000 ],
33 | 		[ [ 2, -3 ], 					 125000000000 ],
34 | 		[ [ 2.1, 3 ], 		    		9261000000000 ],
35 | 		[ [ 2.1, 3.789123456 ],   	   16631395358635 ]
36 | 	];
37 | 	utils.testArray('', data, 12, 10, (instance, t) => {
38 | 		return instance.power_any.call(t[0], t[1]);
39 | 	});
40 | });
41 | 
42 | describe('ExponentLib.root_any', () => {
43 | 	//                      			.123456789012
44 | 	var data = [
45 | 		[ [ 2, 3 ],				1259921049895 ],
46 | 		[ [ 2, -3 ], 			 793700525984 ],
47 | 		[ [ 2.1, 3 ], 		    1280579164987 ],
48 | 		[ [ 2.1, 3.789123456 ], 1216292282161 ]
49 | 	];
50 | 
51 | 	utils.testArray('', data, 12, 10, (instance, t) => {
52 | 		return instance.root_any.call(t[0], t[1]);
53 | 	});
54 | });
55 | 
56 | 


--------------------------------------------------------------------------------
/contracts/LogarithmLib.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.24;
 2 | 
 3 | import "./FixidityLib.sol";
 4 | 
 5 | library LogarithmLib {
 6 | 
 7 |     using FixidityLib for FixidityLib.Fixidity;
 8 | 
 9 |     uint8 constant public longer_digits = 36;
10 |     int256 constant public longer_fixed_log_e_1_5 =     405465108108164381978013115464349137;    
11 |     int256 constant public longer_fixed_1 =            1000000000000000000000000000000000000;    
12 |     int256 constant public longer_fixed_log_e_10 =     2302585092994045684017991454684364208;
13 | 
14 |     function log_e(FixidityLib.Fixidity storage fixidity, int256 v) public view returns (int256) {
15 |         assert(v > 0);
16 |         int256 r = 0;
17 |         uint8 extra_digits = longer_digits - fixidity.digits;
18 |         int256 t = int256(uint256(10) ** uint256(extra_digits));
19 |         while(v <= fixidity.fixed_1 / 10) {
20 |             v = v * 10;
21 |             r -= longer_fixed_log_e_10;
22 |         }
23 |         while(v >= 10 * fixidity.fixed_1) {
24 |             v = v / 10;
25 |             r += longer_fixed_log_e_10;
26 |         }
27 |         while(v < fixidity.fixed_1) {
28 |             v = fixidity.multiply(v, fixidity.fixed_e);
29 |             r -= longer_fixed_1;
30 |         }
31 |         while(v > fixidity.fixed_e) {
32 |             v = fixidity.divide(v, fixidity.fixed_e);
33 |             r += longer_fixed_1;
34 |         }
35 |         if(v == fixidity.fixed_1) {
36 |             return FixidityLib.round_off(fixidity, r, extra_digits) / t;
37 |         }
38 |         if(v == fixidity.fixed_e) {
39 |             return fixidity.fixed_1 + FixidityLib.round_off(fixidity, r, extra_digits) / t;
40 |         }
41 |         v *= t;
42 |         v = v - 3 * longer_fixed_1 / 2;
43 |         r = r + longer_fixed_log_e_1_5;
44 |         int256 m = longer_fixed_1 * v / (v + 3 * longer_fixed_1);
45 |         r = r + 2 * m;
46 |         int256 m_2 = m * m / longer_fixed_1;
47 |         uint8 i = 3;
48 |         while(true) {
49 |             m = m * m_2 / longer_fixed_1;
50 |             r = r + 2 * m / int256(i);
51 |             i += 2;
52 |             if(i >= 3 + 2 * fixidity.digits) break;
53 |         }
54 |         return FixidityLib.round_off(fixidity, r, extra_digits) / t;
55 |     }
56 | 
57 |     function log_any(FixidityLib.Fixidity storage fixidity, int256 base, int256 v) public view returns (int256) {
58 |         return fixidity.divide(log_e(fixidity, v), log_e(fixidity, base));
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/contracts/FixidityLib.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.24;
 2 | 
 3 | library FixidityLib {
 4 | 
 5 |     uint8 constant public initial_digits = 36;
 6 |     int256 constant public fixed_e =            2718281828459045235360287471352662498;
 7 |     int256 constant public fixed_pi =           3141592653589793238462643383279502884;
 8 |     int256 constant public fixed_exp_10 =   22026465794806716516957900645284244000000;
 9 | 
10 | 	struct Fixidity {
11 | 		uint8 digits;
12 | 		int256 fixed_1;
13 | 		int256 fixed_e;
14 |         int256 fixed_pi;
15 |         int256 fixed_exp_10;
16 | 	}
17 | 
18 |     function init(Fixidity storage fixidity, uint8 digits) public {
19 |         assert(digits < 36);
20 |         fixidity.digits = digits;
21 |         fixidity.fixed_1 = int256(uint256(10) ** uint256(digits));
22 |         int256 t = int256(uint256(10) ** uint256(initial_digits - digits));
23 |         fixidity.fixed_e = fixed_e / t;
24 |         fixidity.fixed_pi = fixed_pi / t;
25 |         fixidity.fixed_exp_10 = fixed_exp_10 / t;
26 |     }
27 | 
28 |     function round(Fixidity storage fixidity, int256 v) public view returns (int256) {
29 |         return round_off(fixidity, v, fixidity.digits);
30 |     }
31 | 
32 |     function floor(Fixidity storage fixidity, int256 v) public view returns (int256) {
33 |         return (v / fixidity.fixed_1) * fixidity.fixed_1;
34 |     }
35 | 
36 |     function multiply(Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
37 |         if(b == fixidity.fixed_1) return a;
38 |         int256 x1 = a / fixidity.fixed_1;
39 |         int256 x2 = a - fixidity.fixed_1 * x1;
40 |         int256 y1 = b / fixidity.fixed_1;
41 |         int256 y2 = b - fixidity.fixed_1 * y1;
42 |         return fixidity.fixed_1 * x1 * y1 + x1 * y2 + x2 * y1 + x2 * y2 / fixidity.fixed_1;
43 |     }
44 | 
45 |     function divide(Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
46 |         if(b == fixidity.fixed_1) return a;
47 |         assert(b != 0);
48 |         return multiply(fixidity, a, reciprocal(fixidity, b));
49 |     }
50 | 
51 |     function add(Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
52 |     	int256 t = a + b;
53 |         assert(t - a == b);
54 |     	return t;
55 |     }
56 | 
57 |     function subtract(Fixidity storage fixidity, int256 a, int256 b) public view returns (int256) {
58 |     	int256 t = a - b;
59 |     	assert(t + a == b);
60 |     	return t;
61 |     }
62 | 
63 |     function reciprocal(Fixidity storage fixidity, int256 a) public view returns (int256) {
64 |         return round_off(fixidity, 10 * fixidity.fixed_1 * fixidity.fixed_1 / a, 1) / 10;
65 |     }
66 | 
67 |     function round_off(Fixidity storage fixidity, int256 v, uint8 digits) public view returns (int256) {
68 |         int256 t = int256(uint256(10) ** uint256(digits));
69 |         int8 sign = 1;
70 |         if(v < 0) {
71 |             sign = -1;
72 |             v = 0 - v;
73 |         }
74 |         if(v % t >= t / 2) v = v + t - v % t;
75 |         return v * sign;
76 |     }
77 | 
78 |     function round_to(Fixidity storage fixidity, int256 v, uint8 digits) public view returns (int256) {
79 |         assert(digits < fixidity.digits);
80 |         return round_off(fixidity, v, fixidity.digits - digits);
81 |     }
82 | 
83 |     function trunc_digits(Fixidity storage fixidity, int256 v, uint8 digits) public view returns (int256) {
84 |         if(digits <= 0) return v;
85 |         return round_off(fixidity, v, digits) / (10 ** digits);
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------