Issues - i05nagai/mafipy

Cyclomatic complexity is too high in function sabr_implied_vol_hagan. (12)
Open

def sabr_implied_vol_hagan(
        underlying, strike, maturity, alpha, beta, rho, nu):
    """sabr_implied_vol_hagan
    calculate implied volatility under SABR model.

Found in mafipy/function/sabr.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

`Test_SimpleQuantoCmsLinearBullSpreadHelper` has 24 functions (exceeds 20 allowed). Consider refactoring.
Open

class Test_SimpleQuantoCmsLinearBullSpreadHelper(object):

    # before all tests starts
    @classmethod
    def setup_class(cls):

Found in mafipy/replication/tests/test_pricer_quanto_cms.py - About 2 hrs to fix

`TestBlackScholes` has 24 functions (exceeds 20 allowed). Consider refactoring.
Open

class TestBlackScholes(object):

    # before all tests starts
    @classmethod
    def setup_class(cls):

Found in mafipy/function/tests/test_black_scholes.py - About 2 hrs to fix

Cyclomatic complexity is too high in function sabr_caibration_simple. (10)
Open

def sabr_caibration_simple(market_vols,
                           market_strikes,
                           option_maturity,
                           beta,
                           init_alpha=None,

Found in mafipy/calibrator/sabr.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function parse_setuppy_commands. (9)
Open

def parse_setuppy_commands(args):
    """Check the commands and respond appropriately.  Disable broken commands.
    Return a boolean value for whether or not to run the build or not (avoid
    parsing Cython and template files if False).
    """

Found in setup.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method finalize_options. (9)
Open

    def finalize_options(self):
        TestCommand.finalize_options(self)
        # if cov option is specified, option is replaced.
        if self.cov:
            self.test_args += ["--cov={0}".format(self.cov)]

Found in setup.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function black_scholes_call_value_fhess_by_strike. (9)
Open

def black_scholes_call_value_fhess_by_strike(
        underlying, strike, rate, maturity, vol):
    """black_scholes_call_value_fhess_by_strike
    Second derivative of value of call option with respect to strike
    under black scholes model.

Found in mafipy/function/black_scholes.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method run. (8)
Open

    def run(self):
        if self.run_type is not None:
            self.args += ["{0}".format(self.run_type)]
        if self.bench is not None:
            self.args += ["--bench={0}".format(self.bench)]

Found in setup.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function replicate. (8)
Open

def replicate(init_swap_rate,
              discount_factor,
              call_pricer,
              put_pricer,
              payoff_type,

Found in mafipy/replication/pricer_quanto_cms.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_false. (7)
Open

    @pytest.mark.parametrize(
        "swap_rate, time, vol, corr", [
            # time < 0.0 raise AssertionError
            (2.0, -1.0, 1.0, 0.1),
            # vol < 0.0 raise AssertionError

Found in mafipy/replication/tests/test__quanto_cms_forward_fx.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function black_scholes_put_value. (7)
Open

def black_scholes_put_value(
        underlying,
        strike,
        rate,
        maturity,

Found in mafipy/function/black_scholes.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_true. (7)
Open

    @pytest.mark.parametrize(
        "swap_rate, time, vol, corr", [
            # time < 0.0 raise AssertionError
            (2.0, -1.0, 1.0, 0.1),
            # vol < 0.0 raise AssertionError

Found in mafipy/replication/tests/test__quanto_cms_forward_fx.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_model_black_payers_swaption_volga. (7)
Open

    @pytest.mark.parametrize(
        "init_swap_rate, option_strike, swap_annuity, option_maturity, vol",
        [
            # vol < 0 raise AssertionError
            (1.0, 2.0, 1.0, 1.0, -0.1),

Found in mafipy/function/tests/test_black.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_model_black_payers_swaption_delta. (7)
Open

    @pytest.mark.parametrize(
        "init_swap_rate, option_strike, swap_annuity, option_maturity, vol",
        [
            # vol < 0 raise AssertionError
            (1.0, 2.0, 1.0, 1.0, -0.1),

Found in mafipy/function/tests/test_black.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega_fprime_by_strike. (7)
Open

    @pytest.mark.parametrize(
        "init_swap_rate, option_strike, swap_annuity, option_maturity, vol",
        [
            # vol < 0 raise AssertionError
            (1.0, 2.0, 1.0, 1.0, -0.1),

Found in mafipy/function/tests/test_black.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega. (7)
Open

    @pytest.mark.parametrize(
        "init_swap_rate, option_strike, swap_annuity, option_maturity, vol",
        [
            # vol < 0 raise AssertionError
            (1.0, 2.0, 1.0, 1.0, -0.1),

Found in mafipy/function/tests/test_black.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fprime_false. (6)
Open

    @pytest.mark.parametrize(
        "swap_rate, time, vol, corr", [
            # vol < 0.0 raise AssertionError
            (2.1, 1.2, -1.3, 0.1),
            # corr < -1.0 raise AssertionError

Found in mafipy/replication/tests/test__quanto_cms_forward_fx.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_forward_fx_diffusion_false. (6)
Open

    @pytest.mark.parametrize(
        "swap_rate, time, vol, corr", [
            # is_inverse=False
            # vol < 0.0 raise AssertionError
            (2.1, 1.2, -1.3, 0.1),

Found in mafipy/replication/tests/test__quanto_cms_forward_fx.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method test_black_scholes_call_delta. (6)
Open

    @pytest.mark.parametrize(
        "underlying, strike, rate, maturity, vol, today",
        [
            # vol < 0 raise AssertionError
            (1.1, 1.2, 0.2, 1.3, -0.1, 0.0),

Found in mafipy/function/tests/test_black_scholes.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function sabr_payers_swaption_delta. (6)
Open

def sabr_payers_swaption_delta(
        init_swap_rate, option_strike, swap_annuity, option_maturity,
        alpha, beta, rho, nu):
    """sabr_payers_swaption_delta
    calculate payer's swaption delta under SABR model.

Found in mafipy/function/sabr.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

i05nagai/mafipy

Showing 245 of 1,119 total issues

Cyclomatic complexity is too high in function sabr_implied_vol_hagan. (12) Open

Cyclomatic Complexity

Test_SimpleQuantoCmsLinearBullSpreadHelper has 24 functions (exceeds 20 allowed). Consider refactoring. Open

TestBlackScholes has 24 functions (exceeds 20 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function sabr_caibration_simple. (10) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function parse_setuppy_commands. (9) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method finalize_options. (9) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function black_scholes_call_value_fhess_by_strike. (9) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method run. (8) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function replicate. (8) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_false. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function black_scholes_put_value. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_true. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_model_black_payers_swaption_volga. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_model_black_payers_swaption_delta. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega_fprime_by_strike. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega. (7) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fprime_false. (6) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_forward_fx_diffusion_false. (6) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in method test_black_scholes_call_delta. (6) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function sabr_payers_swaption_delta. (6) Open

Cyclomatic Complexity

Severity

Category

Status

Source

Language

Cyclomatic complexity is too high in function sabr_implied_vol_hagan. (12)
Open

`Test_SimpleQuantoCmsLinearBullSpreadHelper` has 24 functions (exceeds 20 allowed). Consider refactoring.
Open

`TestBlackScholes` has 24 functions (exceeds 20 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function sabr_caibration_simple. (10)
Open

Cyclomatic complexity is too high in function parse_setuppy_commands. (9)
Open

Cyclomatic complexity is too high in method finalize_options. (9)
Open

Cyclomatic complexity is too high in function black_scholes_call_value_fhess_by_strike. (9)
Open

Cyclomatic complexity is too high in method run. (8)
Open

Cyclomatic complexity is too high in function replicate. (8)
Open

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_false. (7)
Open

Cyclomatic complexity is too high in function black_scholes_put_value. (7)
Open

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fhess_true. (7)
Open

Cyclomatic complexity is too high in method test_model_black_payers_swaption_volga. (7)
Open

Cyclomatic complexity is too high in method test_model_black_payers_swaption_delta. (7)
Open

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega_fprime_by_strike. (7)
Open

Cyclomatic complexity is too high in method test_model_black_payers_swaption_vega. (7)
Open

Cyclomatic complexity is too high in method test_forward_fx_diffusion_fprime_false. (6)
Open

Cyclomatic complexity is too high in method test_forward_fx_diffusion_false. (6)
Open

Cyclomatic complexity is too high in method test_black_scholes_call_delta. (6)
Open

Cyclomatic complexity is too high in function sabr_payers_swaption_delta. (6)
Open