Staking math upgrades #2109

dorothy-zbornak · 2019-08-28T23:25:52Z

Description

Flexibler, preciser, efficienter Cobb-Douglas

This PR replaces the math primitives in LibFeeMath with a more flexible, efficient, and precise LibFixedMath library, based on taylor series approximations of natural logs and exponentials.

I previously thought this implementation was more expensive over the original, but these tests say otherwise!

Around 6K gas cheaper over the original, and there is still some room for optimization.
Virtually no restrictions on alpha values (previously they had to be 1/x).
Around 10 more digits of precision over the origianl (~15 now).
Fuzz-tested. Turns out the original would actually completely break under certain conditions.

The two main files of interest for this are LibFixedMath.sol and MixinExchangeFees.sol.

Add `setCobbDouglasAlpha()`

The all-important cobb-douglas alpha factor is now configurable, by the owner, through a setCobbDouglasAlpha() function.

Correct operator stake calculation

Previously we were counting a pool operator's activated (undelegated) + delegated stake in calculating the total stake of a pool. Now we only use the operator's stake delegated to that pool.

Higher precision pool operator share values

All instances of operatorShare are now denominated in parts-per-million (e.g., 500000 == 0.5). This is up from parts-per-100 (e.g., 50 == 0.5).

The delegated stake weight for computing rewards is also now denominated in PPM.

RevertError Bug Fix

There was a bug/bad feature in the way unknown RevertErrors were handled when you did an expect(...).to.revertWith(...) statement. Essentially, any unknown selectors would turn into an AnyRevertError type, which always matches successfully with any other RevertError type.

Now unknown selectors will simply throw an error.

Some minor testing bugs were uncovered (such as new RevertError types not being registered) and fixed in this PR.

Testing instructions

If you run the tests with TEST_ALL=1, you will get a bunch of fuzz tests for the new math primitives and the cobb-douglas function.

Tests run with the UNLIMITED_CONTRACT_SIZE flag for now because the staking contract is >25k yuge.

Types of changes

Breaking change (fix or feature that would cause existing functionality to change)

Checklist:

Prefix PR title with [WIP] if necessary.
Add tests to cover changes as needed.
Update documentation as needed.
Add new entries to the relevant CHANGELOG.jsons.

coveralls · 2019-08-30T07:02:46Z

Coverage remained the same at 75.804% when pulling 356660a on feature/3.0/staking/math-voodoo into e5dcf90 on 3.0.

moodlezoup

This is sick! 🤓
Some nits, but looks great overall.
I have an idea that might increase the precision of CD a bit, see the comment in MixinExchangeFees

moodlezoup · 2019-08-30T18:28:16Z

packages/utils/test/revert_error_test.ts

-            const decode = () => RevertError.decode(_encoded);
-            expect(decode).to.be.throw();
+            const decoded = RevertError.decode(_encoded, true);
+            expect(decoded instanceof RawRevertError).to.be.true();


Suggested change

expect(decoded instanceof RawRevertError).to.be.true();

expect(decoded).to.be.an.instanceof(RawRevertError);

is a thing I think

moodlezoup · 2019-08-30T18:32:47Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

-        protocolFeesThisEpochByPool[poolId] = _feesCollectedThisEpoch.safeAdd(amount);
-        if (_feesCollectedThisEpoch == 0) {
-            activePoolsThisEpoch.push(poolId);
+        if (poolId != 0x0) {


Suggested change

if (poolId != 0x0) {

if (poolId != NIL_MAKER_ID) {

moodlezoup · 2019-08-30T19:14:34Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

+                activePoolsThisEpoch.push(poolId);
+            }
+        } else {
+            // No pool associated with `makerAddress`. Refund the fee.


moodlezoup · 2019-08-30T19:31:46Z

contracts/staking/test/pools_test.ts

@@ -15,6 +15,7 @@ import { StakingWrapper } from './utils/staking_wrapper';
 blockchainTests('Staking Pool Management', env => {
    // constants
    const ZRX_TOKEN_DECIMALS = new BigNumber(18);
+    const PPM_ONE = 1e6;


let's throw these into contracts/staking/test/utils/constants.ts

I guess we could also use DUMMY_TOKEN_DECIMALS from contracts/test-utils/src/constants.ts instead of ZRX_TOKEN_DECIMALS everywhere

moodlezoup · 2019-08-30T19:35:44Z

contracts/staking/test/pools_test.ts

+            const poolOperator = new PoolOperatorActor(operatorAddress, stakingWrapper);
+            // create pool
+            const tx = poolOperator.createStakingPoolAsync(operatorShare);
+            const expectedPoolId = '0x0000000000000000000000000000000100000000000000000000000000000000';


Suggested change

const expectedPoolId = '0x0000000000000000000000000000000100000000000000000000000000000000';

const expectedPoolId = stakingConstants.INITIAL_POOL_ID;

moodlezoup · 2019-08-30T19:54:36Z

contracts/staking/test/utils/number_utils.ts

+export function getNumericalDivergence(a: Numberish, b: Numberish, precision: number = 18): number {
+    const _toInteger = (n: Numberish) => {
+        const _n = new BigNumber(n);
+        const integerDigits = _n.integerValue().sd(true);


I think this should also be integerValue(BigNumber.ROUND_DOWN) because otherwise if e.g. n=999.999... we'd lose a digit of precision

moodlezoup · 2019-08-30T19:56:31Z

contracts/staking/test/simulations_test.ts

@@ -28,7 +29,7 @@ blockchainTests('End-To-End Simulations', env => {
        owner = accounts[0];
        exchange = accounts[1];
        users = accounts.slice(2);
-        users = [...users, ...users]; // @TODO figure out how to get more addresses from `web3Wrapper`
+        users = [...users];


good catch 🎣

moodlezoup · 2019-08-30T20:00:01Z

contracts/test-utils/src/hex_utils.ts

+/**
+ * Convert a string, a number, or a BigNumber into a hex string.
+ */
+export function toHex(n: string | BigNumber | number): string {


On a rainy day, we should combine this with the implementation in the ABI Encoder. This implementation is cleaner; the other supports negative values ~ combined, they'd be unstoppable! 🤓

I don't think I even use this function. I must have added it in a fever dream. But since you bring it up, I updated it to work with negative values.

Ooh that's purdy ~ Ima steal this and put it in the ABI Encoder when you're not looking 🌝

moodlezoup · 2019-08-30T20:05:11Z

packages/utils/src/revert_error.ts

    /**
     * Create a RevertError instance with optional parameter values.
     * Parameters that are left undefined will not be tested in equality checks.
     * @param declaration Function-style declaration of the revert (e.g., Error(string message))
     * @param values Optional mapping of parameters to values.
     */
-    protected constructor(name: string, declaration?: string, values?: ValueMap) {
+    protected constructor(name: string, declaration?: string, values?: ValueMap, raw?: string) {


@param raw

moodlezoup · 2019-08-30T22:22:48Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

+        // totalRewards * stakeRatio * e^(alpha * (ln(feeRatio) - ln(stakeRatio)))
+
+        // Compute e^(alpha * (ln(feeRatio) - ln(stakeRatio)))
+        int256 logFeeRatio = LibFixedMath._ln(feeRatio);


Do you have a good handle on how the error of _ln(x) varies with x?
Given that we get fewer digits of precision in the ln(x), where x is close to 0 test, I assume it's more numerically stable for x closer to 1 –– if that's the case, we might be able to squeeze out a bit more precision using the following observation:
ln(F_i / F) - ln(S_i / S)), ln(F_i / R_i) - ln(F / R), -ln(R_i / F_i) - ln(F / R), ln(R / F) + ln(F_i / R_i), ln(R / F) - ln(R_i / F_i) are all equivalent.
For given values of F_i, R_i, F, R, only one of {ln(F_i / R_i) - ln(F / R), -ln(R_i / F_i) - ln(F / R), ln(R / F) + ln(F_i / R_i), ln(R / F) - ln(R_i / F_i)} will work with _ln, but it might be more stable than ln(F_i / F) - ln(S_i / S)).
So we can do some quick comparisons of F_i, R_i, F, R to get a heuristic of which version will be more precise. This is all a theoretical hunch though, would need testing.

I guess we could also potentially use ln((F_i * R) / (F * R_i)) or -ln((F * R_i) / (F_i * R))

It's way too easy to bait me into a rabbit hole:

error range: [1.006e-17, 1.153103e-14]

It's funny because I originally had your suggestion of ln(x = (F_i * R) / (F * R_i)) but scrapped it since x would be unbounded. Then I added in the conditional inverse but completely forgot that I could now switch back. I'll make the change and run before and after precision tests.

😆 that error curve is jank

You wanna see jank? Check out the error on the native float64 implementation we all know and love.:

So I played around with adding more high order terms to ln() to squeeze out more precision. It was pretty negligible any way I sliced it. The huge error spike towards 1 is probably due to the taylor series not having enough terms, so I can look into generating more of those, but I'm not sure if it's worth the extra gas, since I think. in practice, we won't see inputs near 1.0 if the market is well diversified. Also, 14 digits of precision in these cases is probably good enough, I think?

I also did end up settling on the two following cobb-douglas forms, which saves >1k gas and left precision unchanged. I also refactored it somewhat to hopefully reduce code gen.

totalRewards * stakeRatio * e^(alpha * (ln(feeRatio / stakeRatio))) # if feeRatio <= stakeRatio totalRewards * stakeRatio / e^(alpha * (ln(stakeRatio / feeRatio))) # if feeRatio > stakeRatio

This is because ln(x) has domain 0 < x <= 1 , exp(x) has domain x < 0, and 127-bit fixed-point overflows quite easily when multiplying numbers > ~2.

hysz

This is sooo awesome !! Way cleaner and the precision boost in the tests is unreal.

hysz · 2019-09-03T22:44:02Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

+                activePoolsThisEpoch.push(poolId);
+            }
+        } else {
+            // No pool associated with `makerAddress`. Refund the fee.


Hmm if we do this then the protocol fee becomes optional. Makers could just opt to not create a pool, allowing all of their takers to bypass the protocol fee.

On the flip side, if we keep this $$ then it creates an incentive for market makers to stake.

I wasn't reallly sure what was going to happen on the Exchange side with the fees when I did this. I like the idea of just keeping the fee to sweeten the pot. We should all discuss this. This section will have to be totally overhauled for WETH anyhoo.

hysz · 2019-09-03T22:47:40Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

+        pure
+        returns (uint256 ownerRewards)
+    {
+        assert(alphaNumerator <= alphaDenominator);


How come assert here instead of require?

Because it should never happen through regular use. I just went ahead and removed it.

hysz · 2019-09-03T22:50:35Z

contracts/staking/contracts/src/immutable/MixinConstants.sol

@@ -24,8 +24,7 @@ import "./MixinDeploymentConstants.sol";
 contract MixinConstants is
    MixinDeploymentConstants
 {
-    // TODO: Reevaluate this variable
-    uint8 constant internal PERCENTAGE_DENOMINATOR = 100;
+    uint32 constant internal PPM_ONE = 1000000;


Nit - Renaming to ONE_MILLION or ONE_PPM may be more clear?

or PPM_DENOMINATOR maybe

hysz · 2019-09-03T22:53:08Z

contracts/staking/contracts/src/libs/LibFeeMath.sol

@@ -1,315 +0,0 @@
-
-
-/*


RIP 👏 👏 👏

hysz · 2019-09-03T22:53:38Z

contracts/staking/contracts/src/libs/LibFixedMath.sol

+    int256 private constant EXP_MIN_VAL = -int256(0x0000000000000000000000000000001ff0000000000000000000000000000000);
+
+    /// @dev Get one as a fixed-point number.
+    function _one() internal pure returns (int256 f) {


Consistency nit - IIRC we're no longer prefixing library functions with _

Yeah, I wanted to not, but I figured it was more important to be consistent with the rest of the package, especially with a lot of related PRs in the fray. Aren't we gonna do a convention switch PR at the end anyway?

I think once the outstanding PR's are merged all libraries will follow the new convention. But yeah we'll have to a convention upgrade on internal variables so probably fine to do it then.

hysz · 2019-09-03T23:11:18Z

contracts/test-utils/src/hex_utils.ts

+/**
+ * Convert a string, a number, or a BigNumber into a hex string.
+ */
+export function toHex(n: string | BigNumber | number): string {


On a rainy day, we should combine this with the implementation in the ABI Encoder. This implementation is cleaner; the other supports negative values ~ combined, they'd be unstoppable! 🤓

hysz · 2019-09-03T23:58:01Z

contracts/staking/test/utils/number_utils.ts

+export type Numberish = BigNumber | string | number;
+
+/**
+ * Converts two decimal numbers to integers with `precision` digits, then returns


Nit - "Converts two floating point numbers to integers..."

idk is it fair to call anything that isn't stored in a number a floating point? I think it's gonna be a lie whatever I put in here.

yaaa you can disregard this lol. I think I just dropped it in when I realized we need this fn because the decimal is floating but .. yeah.. too nit.

hysz · 2019-09-04T00:12:38Z

contracts/staking/test/utils/number_utils.ts

+/**
+ * Asserts that two numbers are equal up to `precision` digits.
+ */
+export function assertRoughlyEquals(actual: Numberish, expected: Numberish, precision: number = 18): void {


I'm not sure I understand this function. Don't you lose information about where the decimals are relative to one another?

Suppose we're comparing 8.99 and 11.5 with precision=3. This returns abs(899 - 115) = 784, whereas I would expect something like abs(89 - 115) = 26, which is a closer representation of the true difference of 2.51

You got me! Nice catch.

hysz · 2019-09-04T00:57:59Z

contracts/staking/contracts/src/fees/MixinExchangeFees.sol

+        int256 logFeeRatio = LibFixedMath._ln(feeRatio);
+        int256 logStakeRatio = LibFixedMath._ln(stakeRatio);
+        int256 n;
+        if (logFeeRatio <= logStakeRatio) {


Nit - could be more readable to replace this if/else with something like LibFixedMath._subAbs(logFeeRatio, logStakeRatio).

Is that more readable?? lol

Idk maybe there's a better way but I feel like we can nix the if smt here.

You might be right. It's the domain issues of the primitives that prohibit certain formulations. That said, I don't think this if is costing us much gas, though (there's way more in FixedMath). I'll merge for now but keep thinking about it.

hysz · 2019-09-04T01:07:17Z

contracts/staking/contracts/src/libs/LibFixedMath.sol

+    }
+
+    /// @dev Returns the multiplication two numbers, reverting on overflow.
+    function __mul(int256 a, int256 b) private pure returns (int256 c) {


Since you started working on this we've switched to using LibSafeMath, now that it's a library. Could be good to use it in here as well.

I wasn't sure if I wanted to inherit the same error types for SafeMath in FixedMath. if I did do it I would feel compelled to also throw SafeMath errors in places like __add(), even though it's very different from SafeMath.add(). Then there's other FixedMathError types that don't make sense at all for SafeMath...

moodlezoup

nice work! love the cobb-douglas and fixed math tests

moodlezoup · 2019-09-04T17:33:50Z

contracts/staking/test/cobb_douglas.ts

+import { assertRoughlyEquals, getRandomInteger, getRandomPortion, Numberish, toDecimal } from './utils/number_utils';
+
+// tslint:disable: no-unnecessary-type-assertion
+blockchainTests('Cobb-Douglas', env => {


these tests are slick

moodlezoup · 2019-09-04T17:44:02Z

contracts/staking/contracts/src/libs/LibFixedMathRichErrors.sol

+        0x2bd3386e;
+
+    // solhint-disable func-name-mixedcase
+    function FixedMathSignedValueError(


optional nit: remove the FixedMath prefix from these functions (LibFixedMathRichErrors.FixedMath...Error is a bit redundant)

…as()` in `MixinExchangeFees`. `@0x/contracts-staking`: Update `LibFixedMath` to existing naming conventions. `@0x/contracts-staking`: Add `cobbDouglasAlphaNumerator` and `cobbDouglasAlphaDenominator` to `Mixinstorage`. `@0x/contracts-staking`: Add external `setCobbDouglasAlpha()` function to `MixinExchnageFees` `@0x/contracts-staking`: Update `_cobbDouglas()` to use the new `LibFixedMath` voodoo. `@0x/contracts-staking`: In reward calculations, use only delegated stake by pool owner as opposed to both delegated and active stake to compute stake totals.

`@0x/utils`: Add `LibFixedMath` `RevertError` types. `@0x/order-utils`: Add `InvalidCobbDouglasAlphaerror` `RevertError` type.

…()`, and `hexRightPad()` hex utils.

`@0x/utils`: Have Ganache `Error` -> `RevertError` coercion fail if it can't look up the selector.

… the selector is unknown.

…ptional.

…tError` registry.

…rrors`.

…ut domains and improve precision. `@0x/contracts-staking`: Add `_invert()` and `_mulDiv()` to `LibFixedMath`. `@0x/contracts-staking`: Update `MixinExchangeFees._cobbDouglas()` to work with `LibFixedMath`. `@0x/contracts-staking`: Add unit and fuzz tests for `_cobbDouglas()` and remaining `LibFixedMath` functions.

…lling `setCobbDouglasAlpha()`.

…o 20.

…evertError` type to `InvalidPoolOperatorShareError`.

`@0x/contracts-staking`: Denominate pool operator shares in parts-per-million. `@0x/contracts-staking`: Update tests for new stake computation and higher precision math. `@0x/contracts-staking`: Add `setCobbDouglasAlpha()` function.

…ts`.

…ors.IndexOutOfBoundsError`.

…r changes.

`@0x/contracts-test-utils`: Add `PPM_DENOMINATOR` and `PPM_100_PERCENT` constants.

…Error`. `@0x/utils`: Use `...is.instanceof()` pattern in `RevertError` tests.

`@0x/contracts-staking`: Remove some unecessary asserts. `@0x/contracts-staking`: Fix some broken test assertions. `@0x/contracts-staking`: Generate better random values in tests. `@0x/contracts-staking`: Rename `PPM_ONE` constant to `PPM_DENOMINATOR`. `@0x/contracts-staking`: Minor solidity code improvements. `@0x/contracts-staking`: Use more constants from `@0x/contracts-test-utils` in tests.

…vertError` types.

…FixedMath` revert errors.

hysz

I'm so stoked about this update ~~ let's git er merged! (~‾▿‾)~

dorothy-zbornak force-pushed the feature/3.0/staking/math-voodoo branch from 2d1b7c5 to 074e62c Compare August 29, 2019 17:13

dorothy-zbornak marked this pull request as ready for review August 30, 2019 06:56

dorothy-zbornak requested review from abandeali1, fabioberger and hysz as code owners August 30, 2019 06:56

dorothy-zbornak assigned hysz Aug 30, 2019

dorothy-zbornak changed the title ~~[WIP] Staking math upgrades~~ Staking math upgrades Aug 30, 2019

dorothy-zbornak force-pushed the feature/3.0/staking/math-voodoo branch from bef1983 to 2ab67c7 Compare August 30, 2019 18:37

moodlezoup suggested changes Aug 30, 2019

View reviewed changes

moodlezoup assigned hysz and moodlezoup and unassigned hysz Aug 30, 2019

hysz reviewed Sep 4, 2019

View reviewed changes

dorothy-zbornak requested review from moodlezoup and hysz September 4, 2019 10:17

moodlezoup approved these changes Sep 4, 2019

View reviewed changes

dorothy-zbornak force-pushed the feature/3.0/staking/math-voodoo branch from 8ee2a07 to 9180b63 Compare September 4, 2019 20:43

dorothy-zbornak added 12 commits September 4, 2019 20:15

@0x/contracts-staking: Add LibFeeMath library.

93c8284

@0x/contracts-staking: Add uintMul() function to LibFixedMath.

c1fc454

@0x/contracts-staking: Add rich reverts.

7b5e3da

`@0x/utils`: Add `LibFixedMath` `RevertError` types. `@0x/order-utils`: Add `InvalidCobbDouglasAlphaerror` `RevertError` type.

@0x/contracts-test-utils: Add toHex(), hexInvert(), `hexLeftPad…

0999805

…()`, and `hexRightPad()` hex utils.

@0x/utils: Fix registering FixedMathSignedValueError twice.

1a3da4b

@0x/utils: Fix FixedMathRevertError.FixedMathBinOpError type.

018bcf2

`@0x/utils`: Have Ganache `Error` -> `RevertError` coercion fail if it can't look up the selector.

@0x/utils: Make RevertError.decode() return a RawRevertError if…

2cf74a7

… the selector is unknown.

@0x/order-utils: Add TransactionGasPriceError to error registry.

f71484c

@0x/utils: Make decoding of unknown selectors to RawRevertError o…

0542c70

…ptional.

@0x/order-utils: Add TransactionInvalidContextError to the `Rever…

b100364

…tError` registry.

@0x/utils: Fix order of BinOpErrorCodes enum in `FixedMathRevertE…

7f40665

…rrors`.

dorothy-zbornak and others added 24 commits September 4, 2019 20:18

@0x/contracts-staking: Add a bunch of LibFixedMath unit tests.

1c37334

@0x/contracts-staking: Write LibFixedMath unit tests.

0c6a674

@0x/contracts-staking: Remove unused tslint directives.

c774b98

@0x/contracts-staking: Emit CobbDouglasAlphaChanged event when ca…

ed8a6bb

…lling `setCobbDouglasAlpha()`.

@0x/contracts-staking: Rebase with 3.0

af10f52

@0x/dev-utils: Add total_accounts option to Web3Config.

2e357ff

@0x/contracts-test-utils: Increase the number of ganache accounts t…

5ccbe16

…o 20.

@0x/utils: Prettier.

f724212

@0x/order-utils: Prettier.

a1a5bdc

@0x/utils: Update CHANGELOG.

495bf08

@0x/order-utils: Rename OperatorShareMustBeBetween0And100Error `R…

cb1dc92

…evertError` type to `InvalidPoolOperatorShareError`.

@0x/dev-utils: Remove no longer applicable test case in `chai_test.…

2b3e7e7

…ts`.

@0x/utils: Rename length field to len in `AuthorizableRevertErr…

f601329

…ors.IndexOutOfBoundsError`.

@0x/contracts-utils: Fix failing tests due to RevertError behavio…

b787051

…r changes.

@0x/contracts-test-utils: Allow negative values in toHex().

20ba23f

`@0x/contracts-test-utils`: Add `PPM_DENOMINATOR` and `PPM_100_PERCENT` constants.

@0x/utils: Add docstring for raw constructor parameter in `Revert…

b07fc95

…Error`. `@0x/utils`: Use `...is.instanceof()` pattern in `RevertError` tests.

Commit yarn.lock

0be2c25

@0x/conracts-staking: Fix idiotic linter error.

9bbbaad

@0x/contracts-staking: Keep fees not associated with a pool.

e9eb3ba

@0x/utils: Remove redundant FixedMath prefix from FixedMath `Re…

7c3567f

…vertError` types.

@0x/contracts-staking: Remove redundant "FixedMath" prefix from `…

356660a

…FixedMath` revert errors.

dorothy-zbornak force-pushed the feature/3.0/staking/math-voodoo branch from b691b33 to 356660a Compare September 5, 2019 00:20

hysz approved these changes Sep 5, 2019

View reviewed changes

hysz mentioned this pull request Sep 5, 2019

New staking mechanics #2118

Merged

4 tasks

dorothy-zbornak merged commit 88e5635 into 3.0 Sep 5, 2019

	expect(decoded instanceof RawRevertError).to.be.true();
	expect(decoded).to.be.an.instanceof(RawRevertError);

	const expectedPoolId = '0x0000000000000000000000000000000100000000000000000000000000000000';
	const expectedPoolId = stakingConstants.INITIAL_POOL_ID;

Staking math upgrades #2109

Staking math upgrades #2109

Conversation

dorothy-zbornak commented Aug 28, 2019 • edited Loading

Description

Flexibler, preciser, efficienter Cobb-Douglas

Add setCobbDouglasAlpha()

Correct operator stake calculation

Higher precision pool operator share values

RevertError Bug Fix

Testing instructions

Types of changes

Checklist:

coveralls commented Aug 30, 2019 • edited Loading

moodlezoup left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

dorothy-zbornak Sep 3, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

hysz left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

moodlezoup left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

hysz left a comment

Choose a reason for hiding this comment

dorothy-zbornak commented Aug 28, 2019 •

edited

Loading

Add `setCobbDouglasAlpha()`

coveralls commented Aug 30, 2019 •

edited

Loading

dorothy-zbornak Sep 3, 2019 •

edited

Loading