Sign upLogin

wafo-project/pywafo

View on GitHub
Star
src/wafo/interpolate.py

Summary

Maintainability
F
3 wks
Test Coverage

Function test_func has 29 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_func():
    from scipy import interpolate
    import matplotlib.pyplot as plt
    import matplotlib
    matplotlib.interactive(False)
Severity: Minor
Found in src/wafo/interpolate.py - About 1 hr to fix

    Function demo_monoticity has 26 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    def demo_monoticity():
    # Step function test...
    import matplotlib.pyplot as plt
    plt.figure(2)
    plt.title("pchip() step function test")
    Severity: Minor
    Found in src/wafo/interpolate.py - About 1 hr to fix

      Function interp3 has 8 arguments (exceeds 7 allowed). Consider refactoring.
      Open

      def interp3(x, y, z, v, xi, yi, zi, method='cubic'):
      Severity: Major
      Found in src/wafo/interpolate.py - About 35 mins to fix

        Method "_poly_coefs" has 8 parameters, which is greater than the 7 authorized.
        Open

            def _poly_coefs(self, y, dx, dydx, n, nd, p, D):
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.

        Noncompliant Code Example

        With a maximum number of 4 parameters:

        def do_something(param1, param2, param3, param4, param5):
    ...

        Compliant Solution

        def do_something(param1, param2, param3, param4):
    ...

        Function "interp3" has 8 parameters, which is greater than the 7 authorized.
        Open

        def interp3(x, y, z, v, xi, yi, zi, method='cubic'):
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.

        Noncompliant Code Example

        With a maximum number of 4 parameters:

        def do_something(param1, param2, param3, param4, param5):
    ...

        Compliant Solution

        def do_something(param1, param2, param3, param4):
    ...

        Remove this commented out code.
        Open

            # coef = np.array([[1,1],[1,1],[0,2]]) # linear from 0 to 2
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

                # pieces = len(breaks) - 1
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

            # tck = interpolate.splrep(x, y, s=len(x))
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

        # import scipy.sparse.linalg  # @UnusedImport
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

            # test_smoothing_spline()
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

        #    legends = ["Data", "Pchip()", "interp1d","CHS", 'Stineman']
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

            # yi = np.zeros(xi.shape, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Remove this commented out code.
        Open

            # dy = y-y1
        Severity: Major
        Found in src/wafo/interpolate.py by sonar-python

        Programmers should not comment out code as it bloats programs and reduces readability.

        Unused code should be deleted and can be retrieved from source control history if required.

        See

        • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
        • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
        • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
        • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yp[-1] = 2.0 * dydx[-1] - yp[-2]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 705..705

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 35.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yp[0] = 2.0 * dydx[0] - yp[1]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 706..706

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 35.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                    [dx1[:n - 2], -(dx1[:n - 2] + dx1[1:n - 1]), dx1[1:n - 1]],
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 644..644

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 33.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                data = [dx[1:n - 1], 2 * (dx[:n - 2] + dx[1:n - 1]), dx[:n - 2]]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 637..637

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 33.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                    yp[ii] = tau[ii] * alpha[ii] * dydx[ii]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 802..802

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 31.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                    yp[ii + 1] = tau[ii] * beta[ii] * dydx[ii]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 801..801

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 31.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

            x = linspace(0, 2 * pi + pi / 4, 20)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 1173..1173

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 29.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

            x = linspace(0, 2 * pi + pi / 4, 20)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 1290..1290

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 29.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                dx = newbreaks[[0, -2]] - breaks[[0, -2]]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/doc/tutorial_scripts/rainflow_example.py on lines 53..53

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 29.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            dydx = (y[1:] - y[:-1]) / dx
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 682..682

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 29.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            mk = (y[1:] - y[:-1]) / hk
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 772..772

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 29.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            dk[-1] = _edge_case(mk[-1], dk[-2])
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 697..697

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 28.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            dk[0] = _edge_case(mk[0], dk[1])
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 2 hrs to fix
        src/wafo/interpolate.py on lines 698..698

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 28.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                if yp is None:
            yp = slopes(x, y, method, monotone=monotone)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1007..1008
        src/wafo/interpolate.py on lines 1022..1023

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 25.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                if yp is None:
            yp = slopes(x, y, method, monotone=monotone)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 994..995
        src/wafo/interpolate.py on lines 1022..1023

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 25.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                if yp is None:
            yp = slopes(x, y, method, monotone=False)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 994..995
        src/wafo/interpolate.py on lines 1007..1008

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 25.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            x = np.sin(2 * np.pi * t)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1306..1306

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 25.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            y = np.cos(2 * np.pi * t)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1305..1305

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 25.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[-size:, -size:] = band + np.abs(z[-2:-size - 2:-1, :][:, -2:-size - 2:-1] - band)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 229..229

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 24.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[-size:, size:-size] = band + np.abs(z[-2:-size - 2:-1, :] - band)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 243..243

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 24.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            hk = x[1:] - x[:-1]
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 770..770
        src/wafo/interpolate.py on lines 863..863
        src/wafo/interpolate.py on lines 864..864

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            dx = x[1:] - x[:-1]
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 681..681
        src/wafo/interpolate.py on lines 863..863
        src/wafo/interpolate.py on lines 864..864

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            dy = y[1:] - y[:-1]
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 681..681
        src/wafo/interpolate.py on lines 770..770
        src/wafo/interpolate.py on lines 863..863

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            dx = x[1:] - x[:-1]
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 681..681
        src/wafo/interpolate.py on lines 770..770
        src/wafo/interpolate.py on lines 864..864

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                if a is None:
            a = self.breaks[0]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 331..332

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                dist = alpha ** 2 + beta ** 2
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/padua.py on lines 273..273

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                if b is None:
            b = self.breaks[-1]
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 329..330

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 23.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 12 locations. Consider refactoring.
        Open

        def _assert(cond, msg):
    if not cond:
        raise ValueError(msg)
        Severity: Major
        Found in src/wafo/interpolate.py and 11 other locations - About 1 hr to fix
        src/wafo/integrate.py on lines 24..26
        src/wafo/integrate_oscillating.py on lines 25..27
        src/wafo/kdetools/gridding.py on lines 13..15
        src/wafo/kdetools/kdetools.py on lines 36..38
        src/wafo/kdetools/kernels.py on lines 22..24
        src/wafo/sg_filter/_core.py on lines 20..22
        src/wafo/stats/estimation.py on lines 51..53
        src/wafo/stats/estimation.py on lines 56..58
        src/wafo/stats/estimation.py on lines 61..63
        src/wafo/transform/models.py on lines 38..40
        src/wafo/wave_theory/dispersion_relation.py on lines 17..19

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 22.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            tck = interpolate.splmake(t, y, order=3, kind='smoothest', conds=None)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1295..1296

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 22.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            tck0 = interpolate.splmake(  # @UndefinedVariable
        xnew, ynew, order=3, kind='smoothest', conds=None)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1310..1310

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 22.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[size:-size, -size:] = band + np.abs(z[:, -2:-size - 2:-1] - band)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 243..243

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 21.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                band = z[:, 0].reshape(-1, 1)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 234..234

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 21.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                band = z[:, -1].reshape(-1, 1)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 231..231

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 21.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                new_shape = z.shape[0] + 2 * size, z.shape[1] + 2 * size
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 222..222

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 21.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            coef = np.array([[1, 1], [0, 0]])  # linear from 0 to 2 @UnusedVariable
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1283..1283
        src/wafo/sg_filter/demos.py on lines 166..167
        src/wafo/sg_filter/demos.py on lines 322..323

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 20.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            coef = np.array([[1, 1], [0, 1]])  # linear from 0 to 2
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1317..1317
        src/wafo/sg_filter/demos.py on lines 166..167
        src/wafo/sg_filter/demos.py on lines 322..323

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 20.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                p, u, dx1 = self._init_poly_coefs(dx, dydx, n, p, D)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/stats/core.py on lines 968..968
        src/wafo/stats/core.py on lines 983..983
        src/wafo/stats/core.py on lines 994..994
        src/wafo/stats/estimation.py on lines 483..484

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            if xvals[0] < xvals[1]:  # x is increasing?
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/misc.py on lines 1329..1329
        src/wafo/misc.py on lines 1329..1329
        src/wafo/spectrum/core.py on lines 1180..1180

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

            n_terms = (order + 1) * (order + 2) // 2
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/padua.py on lines 292..292
        src/wafo/padua.py on lines 397..397
        src/wafo/stats/_continuous_distns.py on lines 1420..1420

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            condition = ((smk[1:] != smk[:-1]) | (mk[1:] == 0) | (mk[:-1] == 0))
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/kdetools/kdetools.py on lines 1156..1156

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yp[1:-1] = (dydx[:-1] + dydx[1:]) / 2.0
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 704..704

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            if turnpoint == 0:  # no change in direction of x
        return savitzky_golay(data, kernel, order)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/integrate.py on lines 834..835

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yp[1:-1] = (dydx[:-1] * dx[1:] + dydx[1:] * dx[:-1]) / (dx[1:] + dx[:-1])
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 716..716

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                QQ = (6 * (1 - p)) * (QDQ) + p * R
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 591..591

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                    ai = (y - (6 * (1 - p) * Qu).T).T
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 655..655

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 19.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 3 locations. Consider refactoring.
        Open

                yyp = [z for z in zip(y, yp)]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1024..1024
        src/wafo/interpolate.py on lines 1126..1126

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 18.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 3 locations. Consider refactoring.
        Open

                yyp = [z for z in zip(y, yp)]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1009..1009
        src/wafo/interpolate.py on lines 1126..1126

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 18.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 3 locations. Consider refactoring.
        Open

                yyp = [z for z in zip(y, yp)]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1009..1009
        src/wafo/interpolate.py on lines 1024..1024

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 18.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            _assert(x.shape == y.shape, 'Shapes of x and y must be equal!')
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/kdetools/kernels.py on lines 105..106

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 18.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 15 locations. Consider refactoring.
        Open

            window_size = np.abs(np.int(window_size))
        Severity: Major
        Found in src/wafo/interpolate.py and 14 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 91..91
        src/wafo/kdetools/kdetools.py on lines 1097..1100
        src/wafo/kdetools/kdetools.py on lines 1155..1155
        src/wafo/kdetools/kdetools.py on lines 1192..1192
        src/wafo/markov.py on lines 32..32
        src/wafo/markov.py on lines 609..609
        src/wafo/markov.py on lines 684..684
        src/wafo/misc.py on lines 1672..1672
        src/wafo/stats/_continuous_distns.py on lines 5428..5428
        src/wafo/stats/_continuous_distns.py on lines 5444..5444
        src/wafo/stats/core.py on lines 891..891
        src/wafo/stats/estimation.py on lines 386..386
        src/wafo/stats/estimation.py on lines 1157..1157
        src/wafo/tests/test_gaussian.py on lines 45..45

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 15 locations. Consider refactoring.
        Open

            order = np.abs(np.int(order))
        Severity: Major
        Found in src/wafo/interpolate.py and 14 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 90..90
        src/wafo/kdetools/kdetools.py on lines 1097..1100
        src/wafo/kdetools/kdetools.py on lines 1155..1155
        src/wafo/kdetools/kdetools.py on lines 1192..1192
        src/wafo/markov.py on lines 32..32
        src/wafo/markov.py on lines 609..609
        src/wafo/markov.py on lines 684..684
        src/wafo/misc.py on lines 1672..1672
        src/wafo/stats/_continuous_distns.py on lines 5428..5428
        src/wafo/stats/_continuous_distns.py on lines 5444..5444
        src/wafo/stats/core.py on lines 891..891
        src/wafo/stats/estimation.py on lines 386..386
        src/wafo/stats/estimation.py on lines 1157..1157
        src/wafo/tests/test_gaussian.py on lines 45..45

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 13 locations. Consider refactoring.
        Open

                x, y, var = np.atleast_1d(xx, yy, var)
        Severity: Major
        Found in src/wafo/interpolate.py and 12 other locations - About 1 hr to fix
        src/wafo/covariance/core.py on lines 604..604
        src/wafo/covariance/core.py on lines 643..643
        src/wafo/gaussian.py on lines 846..846
        src/wafo/interpolate.py on lines 615..615
        src/wafo/misc.py on lines 2585..2585
        src/wafo/sg_filter/_core.py on lines 1188..1189
        src/wafo/sg_filter/_core.py on lines 1188..1191
        src/wafo/sg_filter/_core.py on lines 1203..1203
        src/wafo/stats/_continuous_distns.py on lines 4632..4632
        src/wafo/stats/_continuous_distns.py on lines 4678..4678
        src/wafo/wave_theory/core.py on lines 329..329
        src/wafo/wave_theory/dispersion_relation.py on lines 147..147

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 13 locations. Consider refactoring.
        Open

                x, y, dx = self._spacing(xx, yy, var)
        Severity: Major
        Found in src/wafo/interpolate.py and 12 other locations - About 1 hr to fix
        src/wafo/covariance/core.py on lines 604..604
        src/wafo/covariance/core.py on lines 643..643
        src/wafo/gaussian.py on lines 846..846
        src/wafo/interpolate.py on lines 560..560
        src/wafo/misc.py on lines 2585..2585
        src/wafo/sg_filter/_core.py on lines 1188..1189
        src/wafo/sg_filter/_core.py on lines 1188..1191
        src/wafo/sg_filter/_core.py on lines 1203..1203
        src/wafo/stats/_continuous_distns.py on lines 4632..4632
        src/wafo/stats/_continuous_distns.py on lines 4678..4678
        src/wafo/wave_theory/core.py on lines 329..329
        src/wafo/wave_theory/dispersion_relation.py on lines 147..147

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                coefs, brks = self._compute_coefs(xx, yy, p, var)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/integrate.py on lines 1190..1190
        src/wafo/integrate.py on lines 1219..1219
        src/wafo/integrate_oscillating.py on lines 266..266
        src/wafo/integrate_oscillating.py on lines 311..311

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

                dydx = np.diff(y) / dx
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 1 hr to fix
        src/wafo/kdetools/kernels.py on lines 804..804
        src/wafo/kdetools/kernels.py on lines 1004..1004
        src/wafo/kdetools/kernels.py on lines 1108..1108
        src/wafo/kdetools/kernels.py on lines 1235..1235
        src/wafo/sg_filter/demos.py on lines 48..48
        src/wafo/stats/_continuous_distns.py on lines 4458..4458

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                    index = np.arange(pieces - 1)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/spectrum/core.py on lines 2336..2336
        src/wafo/spectrum/core.py on lines 2358..2358
        src/wafo/stats/_continuous_distns.py on lines 7984..7984

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                elif (dx <= 0).any():
            raise ValueError('Two consecutive values in x can not be equal.')
        elif n != ny:
            raise ValueError('x and y must have the same length.')
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/gaussian.py on lines 340..341
        src/wafo/markov.py on lines 58..59
        src/wafo/stats/core.py on lines 910..911

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                super(CubicHermiteSpline, self).__init__(bpoly.c, x)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1011..1011
        src/wafo/interpolate.py on lines 1128..1128

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            half_window = (window_size - 1) // 2
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/demos.py on lines 35..35
        src/wafo/misc.py on lines 2276..2276

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            m = slopes(x, y, method='parabola', monotone=True)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1205..1205
        src/wafo/interpolate.py on lines 1206..1206

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                coefs = self._poly_coefs(y, dx, dydx, n, nd, p, D)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/covariance/core.py on lines 677..678
        src/wafo/spectrum/core.py on lines 1286..1286

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                tau = 3.0 / np.sqrt(dist)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/stats/_continuous_distns.py on lines 6905..6905
        src/wafo/stats/_continuous_distns.py on lines 7567..7567

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            m1 = slopes(x, y, method='parabola', monotone=False)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1204..1204
        src/wafo/interpolate.py on lines 1206..1206

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

        __all__ = [
    'PPform', 'savitzky_golay', 'savitzky_golay_piecewise', 'sgolay2d',
    'SmoothSpline', 'pchip_slopes', 'slopes', 'stineman_interp', 'Pchip',
    'StinemanInterp', 'CubicHermiteSpline']
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        docs/conf.py on lines 60..71
        src/wafo/stats/core.py on lines 12..15

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                pieces = len(self.breaks) - 1
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/covariance/core.py on lines 287..287
        src/wafo/objects.py on lines 1510..1510

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            m2 = slopes(x, y, method='catmul', monotone=False)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1204..1204
        src/wafo/interpolate.py on lines 1205..1205

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                super(StinemanInterp2, self).__init__(bpoly.c, x)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1026..1026
        src/wafo/interpolate.py on lines 1128..1128

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                super(Pchip, self).__init__(bpoly.c, x)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 1011..1011
        src/wafo/interpolate.py on lines 1026..1026

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                alpha = yp[:-1] / dydx
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 788..788

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            pp = PPform(coef, breaks, a=-100, b=100)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/transform/tests/test_trdata.py on lines 19..19

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            xvec = np.arange(250.) / 100.
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1196..1196

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            xidxp1 = x.take(idx + 1)
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/integrate_oscillating.py on lines 46..46

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            x = np.arange(30.0) / 10.
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 1200..1200

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                beta = yp[1:] / dydx
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 787..787

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 17.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

            ynew = interpolate.splev(xnew, tck, der=0)  # @UndefinedVariable
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 1 hr to fix
        src/wafo/integrate_oscillating.py on lines 115..115
        src/wafo/integrate_oscillating.py on lines 403..403
        src/wafo/interpolate.py on lines 1025..1025
        src/wafo/interpolate.py on lines 1127..1127
        src/wafo/spectrum/core.py on lines 830..830
        src/wafo/stats/_continuous_distns.py on lines 2842..2842

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

                bpoly = BPoly.from_derivatives(x, yyp, orders=3)
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 1 hr to fix
        src/wafo/integrate_oscillating.py on lines 115..115
        src/wafo/integrate_oscillating.py on lines 403..403
        src/wafo/interpolate.py on lines 1127..1127
        src/wafo/interpolate.py on lines 1294..1294
        src/wafo/spectrum/core.py on lines 830..830
        src/wafo/stats/_continuous_distns.py on lines 2842..2842

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

                bpoly = BPoly.from_derivatives(x, yyp, orders=3)
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 1 hr to fix
        src/wafo/integrate_oscillating.py on lines 115..115
        src/wafo/integrate_oscillating.py on lines 403..403
        src/wafo/interpolate.py on lines 1025..1025
        src/wafo/interpolate.py on lines 1294..1294
        src/wafo/spectrum/core.py on lines 830..830
        src/wafo/stats/_continuous_distns.py on lines 2842..2842

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                a_1 = pl.polyreloc(a_11, -dx1)  # Relocate first polynomial
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 391..391
        src/wafo/stats/_continuous_distns.py on lines 4107..4107
        src/wafo/stats/_continuous_distns.py on lines 4112..4112
        src/wafo/stats/estimation.py on lines 881..881

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            yp = np.zeros(y.shape, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 703..703
        src/wafo/interpolate.py on lines 721..721
        src/wafo/stats/estimation.py on lines 365..365
        src/wafo/stats/estimation.py on lines 1310..1311

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            function = ip.interp1d(x, y, kind='cubic')
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/kdetools/tests/test_kdetools.py on lines 240..240
        src/wafo/kdetools/tests/test_kdetools.py on lines 351..351
        src/wafo/kdetools/tests/test_kdetools.py on lines 371..371
        src/wafo/spectrum/core.py on lines 3513..3513

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                a_n = pl.polyreloc(a_nn, -dxN)  # Relocate last polynomial
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 403..403
        src/wafo/stats/_continuous_distns.py on lines 4107..4107
        src/wafo/stats/_continuous_distns.py on lines 4112..4112
        src/wafo/stats/estimation.py on lines 881..881

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            yp = np.zeros(y.shape, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 711..711
        src/wafo/interpolate.py on lines 721..721
        src/wafo/stats/estimation.py on lines 365..365
        src/wafo/stats/estimation.py on lines 1310..1311

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            yp = np.zeros(y.shape, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 703..703
        src/wafo/interpolate.py on lines 711..711
        src/wafo/stats/estimation.py on lines 365..365
        src/wafo/stats/estimation.py on lines 1310..1311

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                self.yp = np.asarray(yp, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 996..996
        src/wafo/interpolate.py on lines 997..997
        src/wafo/sg_filter/_core.py on lines 288..288

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                self.x = np.asarray(x, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 997..997
        src/wafo/interpolate.py on lines 998..998
        src/wafo/sg_filter/_core.py on lines 288..288

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                self.y = np.asarray(y, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 1 hr to fix
        src/wafo/interpolate.py on lines 996..996
        src/wafo/interpolate.py on lines 998..998
        src/wafo/sg_filter/_core.py on lines 288..288

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            slope_fun = dict(par=_parabola_slope, sec=_secant_slope, car=_cardinal_slope,
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/spectrum/core.py on lines 1775..1775

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                dx.shape = n - 1, -1
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 579..579

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                dx1.shape = n - 1, -1
        Severity: Major
        Found in src/wafo/interpolate.py and 1 other location - About 1 hr to fix
        src/wafo/interpolate.py on lines 580..580

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 16.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 18 locations. Consider refactoring.
        Open

        if __name__ == '__main__':
    # test_func()
    test_docstrings()
        Severity: Major
        Found in src/wafo/interpolate.py and 17 other locations - About 55 mins to fix
        source/c_library/build_all.py on lines 24..25
        source/mreg/build_all.py on lines 29..30
        source/mvn/build_all.py on lines 19..20
        source/mvnprd/build_all.py on lines 25..26
        source/mvnprd/old/mvnprodcorrprb/build_all.py on lines 23..24
        source/rind2007/build_all.py on lines 31..32
        src/wafo/covariance/tests/test_covariance.py on lines 27..28
        src/wafo/graphutil.py on lines 276..277
        src/wafo/objects.py on lines 2619..2620
        src/wafo/spectrum/core.py on lines 4415..4416
        src/wafo/spectrum/models.py on lines 2172..2173
        src/wafo/stats/core.py on lines 1495..1497
        src/wafo/stats/estimation.py on lines 1693..1695
        src/wafo/wave_theory/core.py on lines 595..596
        src/wafo/wavemodels.py on lines 267..268
        build_package.py on lines 125..126
        setup.py on lines 209..210

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 31 locations. Consider refactoring.
        Open

            X, Y = np.meshgrid(xi, yi)
        Severity: Major
        Found in src/wafo/interpolate.py and 30 other locations - About 55 mins to fix
        src/wafo/containers.py on lines 203..203
        src/wafo/demos.py on lines 13..13
        src/wafo/demos.py on lines 23..23
        src/wafo/graphutil.py on lines 214..215
        src/wafo/integrate.py on lines 83..83
        src/wafo/kdetools/gridding.py on lines 339..339
        src/wafo/kdetools/kernels.py on lines 116..116
        src/wafo/markov.py on lines 489..493
        src/wafo/misc.py on lines 494..494
        src/wafo/misc.py on lines 1334..1334
        src/wafo/misc.py on lines 2429..2429
        src/wafo/padua.py on lines 326..326
        src/wafo/padua.py on lines 475..475
        src/wafo/padua.py on lines 513..513
        src/wafo/sg_filter/demos.py on lines 418..418
        src/wafo/spectrum/models.py on lines 2099..2099
        src/wafo/spectrum/models.py on lines 2108..2108
        src/wafo/stats/_continuous_distns.py on lines 3779..3779
        src/wafo/stats/core.py on lines 495..495
        src/wafo/stats/core.py on lines 534..534
        src/wafo/stats/core.py on lines 937..937
        src/wafo/stats/estimation.py on lines 474..474
        src/wafo/stats/estimation.py on lines 482..482
        src/wafo/tests/test_gaussian.py on lines 47..47
        src/wafo/tests/test_gaussian.py on lines 154..154
        src/wafo/tests/test_misc.py on lines 546..546
        src/wafo/tests/test_misc.py on lines 556..556
        src/wafo/tests/test_misc.py on lines 569..569
        src/wafo/transform/models.py on lines 231..231
        src/wafo/transform/models.py on lines 240..240

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 9 locations. Consider refactoring.
        Open

            plt.plot(x, y, 'ro', label='Data')
        Severity: Major
        Found in src/wafo/interpolate.py and 8 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 728..728
        src/wafo/interpolate.py on lines 1263..1263
        src/wafo/interpolate.py on lines 1264..1264
        src/wafo/interpolate.py on lines 1265..1265
        src/wafo/interpolate.py on lines 1266..1266
        src/wafo/kdetools/demo.py on lines 240..240
        src/wafo/kdetools/demo.py on lines 241..241
        src/wafo/kdetools/demo.py on lines 318..318

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 9 locations. Consider refactoring.
        Open

            plt.plot(xvec, yvec2, 'k', label='interp1d')
        Severity: Major
        Found in src/wafo/interpolate.py and 8 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 728..728
        src/wafo/interpolate.py on lines 1262..1262
        src/wafo/interpolate.py on lines 1263..1263
        src/wafo/interpolate.py on lines 1265..1265
        src/wafo/interpolate.py on lines 1266..1266
        src/wafo/kdetools/demo.py on lines 240..240
        src/wafo/kdetools/demo.py on lines 241..241
        src/wafo/kdetools/demo.py on lines 318..318

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 9 locations. Consider refactoring.
        Open

            plt.plot(xvec, yvec, 'b', label='Pchip')
        Severity: Major
        Found in src/wafo/interpolate.py and 8 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 728..728
        src/wafo/interpolate.py on lines 1262..1262
        src/wafo/interpolate.py on lines 1264..1264
        src/wafo/interpolate.py on lines 1265..1265
        src/wafo/interpolate.py on lines 1266..1266
        src/wafo/kdetools/demo.py on lines 240..240
        src/wafo/kdetools/demo.py on lines 241..241
        src/wafo/kdetools/demo.py on lines 318..318

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 9 locations. Consider refactoring.
        Open

            plt.plot(xvec, yvec4, 'm', label='Stineman')
        Severity: Major
        Found in src/wafo/interpolate.py and 8 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 728..728
        src/wafo/interpolate.py on lines 1262..1262
        src/wafo/interpolate.py on lines 1263..1263
        src/wafo/interpolate.py on lines 1264..1264
        src/wafo/interpolate.py on lines 1265..1265
        src/wafo/kdetools/demo.py on lines 240..240
        src/wafo/kdetools/demo.py on lines 241..241
        src/wafo/kdetools/demo.py on lines 318..318

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 9 locations. Consider refactoring.
        Open

            plt.plot(xvec, yvec3, 'g', label='CHS')
        Severity: Major
        Found in src/wafo/interpolate.py and 8 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 728..728
        src/wafo/interpolate.py on lines 1262..1262
        src/wafo/interpolate.py on lines 1263..1263
        src/wafo/interpolate.py on lines 1264..1264
        src/wafo/interpolate.py on lines 1266..1266
        src/wafo/kdetools/demo.py on lines 240..240
        src/wafo/kdetools/demo.py on lines 241..241
        src/wafo/kdetools/demo.py on lines 318..318

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec1 = Pchip(x, y, m1)(xvec)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1210..1210
        src/wafo/interpolate.py on lines 1212..1212
        src/wafo/interpolate.py on lines 1213..1213
        src/wafo/interpolate.py on lines 1248..1248
        src/wafo/interpolate.py on lines 1259..1259

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec3 = Pchip(x, y, m3)(xvec)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1210..1210
        src/wafo/interpolate.py on lines 1211..1211
        src/wafo/interpolate.py on lines 1212..1212
        src/wafo/interpolate.py on lines 1248..1248
        src/wafo/interpolate.py on lines 1259..1259

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec5 = Pchip(x, y, m3)(xvec)  # @UnusedVariable
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1210..1210
        src/wafo/interpolate.py on lines 1211..1211
        src/wafo/interpolate.py on lines 1212..1212
        src/wafo/interpolate.py on lines 1213..1213
        src/wafo/interpolate.py on lines 1248..1248

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

                v = pp(qi[j])
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/covariance/core.py on lines 681..681
        src/wafo/fig.py on lines 717..717
        src/wafo/gaussian.py on lines 860..860
        src/wafo/kdetools/gridding.py on lines 190..190
        src/wafo/stats/estimation.py on lines 408..408

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec = Pchip(x, y, m)(xvec)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1211..1211
        src/wafo/interpolate.py on lines 1212..1212
        src/wafo/interpolate.py on lines 1213..1213
        src/wafo/interpolate.py on lines 1248..1248
        src/wafo/interpolate.py on lines 1259..1259

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec2 = Pchip(x, y, m2)(xvec)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1210..1210
        src/wafo/interpolate.py on lines 1211..1211
        src/wafo/interpolate.py on lines 1213..1213
        src/wafo/interpolate.py on lines 1248..1248
        src/wafo/interpolate.py on lines 1259..1259

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yvec = Pchip(x, y, m)(xvec)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 55 mins to fix
        src/wafo/interpolate.py on lines 1210..1210
        src/wafo/interpolate.py on lines 1211..1211
        src/wafo/interpolate.py on lines 1212..1212
        src/wafo/interpolate.py on lines 1213..1213
        src/wafo/interpolate.py on lines 1259..1259

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                super(SmoothSpline, self).__init__(coefs, brks)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 55 mins to fix
        src/wafo/spectrum/models.py on lines 245..245
        src/wafo/spectrum/models.py on lines 533..533
        src/wafo/spectrum/models.py on lines 897..897

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            y = np.concatenate((firstvals, y, lastvals))
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 55 mins to fix
        src/wafo/kdetools/tests/test_gridding.py on lines 54..54
        src/wafo/sg_filter/demos.py on lines 173..173

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            y = sin(x) + np.random.randn(np.size(x))
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 55 mins to fix
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 56..56
        src/wafo/sg_filter/demos.py on lines 397..397

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                exps = [(k - n, n) for k in range(order + 1) for n in range(k + 1)]
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 55 mins to fix
        src/wafo/interpolate.py on lines 264..264

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 15.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            y = np.asarray(y, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 767..767
        src/wafo/interpolate.py on lines 768..768
        src/wafo/interpolate.py on lines 850..850
        src/wafo/interpolate.py on lines 854..857
        src/wafo/interpolate.py on lines 859..859
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            if yp is None:
        yp = slopes(x, y)
    else:
        yp = np.asarray(yp, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 767..767
        src/wafo/interpolate.py on lines 768..768
        src/wafo/interpolate.py on lines 850..850
        src/wafo/interpolate.py on lines 851..851
        src/wafo/interpolate.py on lines 859..859
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            xi = np.asarray(xi, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 767..767
        src/wafo/interpolate.py on lines 768..768
        src/wafo/interpolate.py on lines 850..850
        src/wafo/interpolate.py on lines 851..851
        src/wafo/interpolate.py on lines 854..857
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            x = np.asarray(x, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 767..767
        src/wafo/interpolate.py on lines 768..768
        src/wafo/interpolate.py on lines 851..851
        src/wafo/interpolate.py on lines 854..857
        src/wafo/interpolate.py on lines 859..859
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            y = np.asarray(y, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 767..767
        src/wafo/interpolate.py on lines 850..850
        src/wafo/interpolate.py on lines 851..851
        src/wafo/interpolate.py on lines 854..857
        src/wafo/interpolate.py on lines 859..859
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 11 locations. Consider refactoring.
        Open

            x = np.asarray(x, np.float_)
        Severity: Major
        Found in src/wafo/interpolate.py and 10 other locations - About 50 mins to fix
        src/wafo/interpolate.py on lines 768..768
        src/wafo/interpolate.py on lines 850..850
        src/wafo/interpolate.py on lines 851..851
        src/wafo/interpolate.py on lines 854..857
        src/wafo/interpolate.py on lines 859..859
        src/wafo/sg_filter/_core.py on lines 391..392
        src/wafo/sg_filter/_core.py on lines 507..507
        src/wafo/sg_filter/_core.py on lines 1023..1023
        src/wafo/stats/_continuous_distns.py on lines 6364..6364
        src/wafo/stats/_continuous_distns.py on lines 8276..8277

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[:size, size:-size] = band - np.abs(z[size:0:-1, :] - band)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 240..240

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[:size, :size] = band - np.abs(z[size:0:-1, :][:, size:0:-1] - band)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 226..226

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                u = self._compute_u(qq, p, dydx, n)
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 50 mins to fix
        src/wafo/integrate.py on lines 1016..1016
        src/wafo/kdetools/kdetools.py on lines 715..715
        src/wafo/objects.py on lines 2106..2107

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 4 locations. Consider refactoring.
        Open

                a_nn = coefs[:, -1]
        Severity: Major
        Found in src/wafo/interpolate.py and 3 other locations - About 50 mins to fix
        src/wafo/graphutil.py on lines 246..247
        src/wafo/kdetools/gridding.py on lines 60..60
        src/wafo/kdetools/gridding.py on lines 61..61

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            m = slopes(x, y, monotone=True)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/kdetools/kernels.py on lines 128..128
        src/wafo/tests/test_misc.py on lines 694..694

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            plt.plot(t, self(t))
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/spectrum/models.py on lines 2071..2071
        src/wafo/spectrum/models.py on lines 2093..2093

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                v = pp[0, indxs]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/objects.py on lines 314..314
        src/wafo/objects.py on lines 315..315

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            pp = SmoothSpline(x, y, p=1)
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/covariance/core.py on lines 436..436
        src/wafo/covariance/core.py on lines 446..446

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                band = z[0, 0]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/integrate.py on lines 183..183
        src/wafo/interpolate.py on lines 242..242

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                band = z[-1, -1]
        Severity: Major
        Found in src/wafo/interpolate.py and 2 other locations - About 50 mins to fix
        src/wafo/integrate.py on lines 183..183
        src/wafo/interpolate.py on lines 239..239

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yvec3 = CubicHermiteSpline(x, y)(xvec)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 1258..1258

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            yvec4 = StinemanInterp(x, y)(xvec)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 1257..1257

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                band = z[0, :]
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 228..228

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                band = z[-1, :]
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 50 mins to fix
        src/wafo/interpolate.py on lines 225..225

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 14.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            x = np.linspace(0, 1, 5)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            y = np.linspace(0, 2, 6)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            yi = np.linspace(0, 2, 46)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            z = np.linspace(0, 3, 7)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            t = np.arange(0, 1.1, .1)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 36 locations. Consider refactoring.
        Open

                qq = self._compute_qq(p, qdq, R)
        Severity: Major
        Found in src/wafo/interpolate.py and 35 other locations - About 45 mins to fix
        src/wafo/containers.py on lines 235..236
        src/wafo/containers.py on lines 307..307
        src/wafo/integrate.py on lines 1014..1014
        src/wafo/integrate.py on lines 1412..1412
        src/wafo/integrate_oscillating.py on lines 442..442
        src/wafo/integrate_oscillating.py on lines 492..492
        src/wafo/interpolate.py on lines 574..574
        src/wafo/kdetools/kdetools.py on lines 712..712
        src/wafo/kdetools/kernels.py on lines 820..820
        src/wafo/kdetools/kernels.py on lines 912..912
        src/wafo/kdetools/kernels.py on lines 1018..1018
        src/wafo/kdetools/kernels.py on lines 1139..1139
        src/wafo/kdetools/kernels.py on lines 1247..1247
        src/wafo/misc.py on lines 248..248
        src/wafo/misc.py on lines 1339..1339
        src/wafo/misc.py on lines 1393..1393
        src/wafo/misc.py on lines 2248..2248
        src/wafo/misc.py on lines 2260..2260
        src/wafo/misc.py on lines 2262..2262
        src/wafo/misc.py on lines 2273..2273
        src/wafo/misc.py on lines 2292..2292
        src/wafo/misc.py on lines 2461..2461
        src/wafo/objects.py on lines 446..446
        src/wafo/objects.py on lines 978..978
        src/wafo/sg_filter/_core.py on lines 429..429
        src/wafo/sg_filter/_core.py on lines 1167..1167
        src/wafo/sg_filter/_core.py on lines 1168..1168
        src/wafo/sg_filter/_core.py on lines 1169..1169
        src/wafo/sg_filter/demos.py on lines 424..424
        src/wafo/sg_filter/demos.py on lines 426..426
        src/wafo/sg_filter/demos.py on lines 428..428
        src/wafo/spectrum/models.py on lines 1582..1582
        src/wafo/stats/_continuous_distns.py on lines 3870..3870
        src/wafo/stats/estimation.py on lines 534..537
        src/wafo/transform/models.py on lines 72..72

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 36 locations. Consider refactoring.
        Open

                qdq = self._compute_qdq(D, dx1, n)
        Severity: Major
        Found in src/wafo/interpolate.py and 35 other locations - About 45 mins to fix
        src/wafo/containers.py on lines 235..236
        src/wafo/containers.py on lines 307..307
        src/wafo/integrate.py on lines 1014..1014
        src/wafo/integrate.py on lines 1412..1412
        src/wafo/integrate_oscillating.py on lines 442..442
        src/wafo/integrate_oscillating.py on lines 492..492
        src/wafo/interpolate.py on lines 577..577
        src/wafo/kdetools/kdetools.py on lines 712..712
        src/wafo/kdetools/kernels.py on lines 820..820
        src/wafo/kdetools/kernels.py on lines 912..912
        src/wafo/kdetools/kernels.py on lines 1018..1018
        src/wafo/kdetools/kernels.py on lines 1139..1139
        src/wafo/kdetools/kernels.py on lines 1247..1247
        src/wafo/misc.py on lines 248..248
        src/wafo/misc.py on lines 1339..1339
        src/wafo/misc.py on lines 1393..1393
        src/wafo/misc.py on lines 2248..2248
        src/wafo/misc.py on lines 2260..2260
        src/wafo/misc.py on lines 2262..2262
        src/wafo/misc.py on lines 2273..2273
        src/wafo/misc.py on lines 2292..2292
        src/wafo/misc.py on lines 2461..2461
        src/wafo/objects.py on lines 446..446
        src/wafo/objects.py on lines 978..978
        src/wafo/sg_filter/_core.py on lines 429..429
        src/wafo/sg_filter/_core.py on lines 1167..1167
        src/wafo/sg_filter/_core.py on lines 1168..1168
        src/wafo/sg_filter/_core.py on lines 1169..1169
        src/wafo/sg_filter/demos.py on lines 424..424
        src/wafo/sg_filter/demos.py on lines 426..426
        src/wafo/sg_filter/demos.py on lines 428..428
        src/wafo/spectrum/models.py on lines 1582..1582
        src/wafo/stats/_continuous_distns.py on lines 3870..3870
        src/wafo/stats/estimation.py on lines 534..537
        src/wafo/transform/models.py on lines 72..72

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            xi = np.linspace(0, 1, 45)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1157..1157
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 37 locations. Consider refactoring.
        Open

            zi = np.linspace(0, 3, 47)
        Severity: Major
        Found in src/wafo/interpolate.py and 36 other locations - About 45 mins to fix
        src/wafo/doc/tutorial_scripts/chapter3.py on lines 37..37
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 97..97
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 184..184
        src/wafo/interpolate.py on lines 1149..1149
        src/wafo/interpolate.py on lines 1150..1150
        src/wafo/interpolate.py on lines 1151..1151
        src/wafo/interpolate.py on lines 1155..1155
        src/wafo/interpolate.py on lines 1156..1156
        src/wafo/interpolate.py on lines 1304..1304
        src/wafo/kdetools/demo.py on lines 31..31
        src/wafo/kdetools/demo.py on lines 68..68
        src/wafo/kdetools/kernels.py on lines 923..923
        src/wafo/objects.py on lines 415..415
        src/wafo/sg_filter/demos.py on lines 20..20
        src/wafo/sg_filter/demos.py on lines 381..381
        src/wafo/sg_filter/demos.py on lines 417..417
        src/wafo/sg_filter/tests/test_sg_filter.py on lines 37..37
        src/wafo/spectrum/core.py on lines 4401..4401
        src/wafo/spectrum/models.py on lines 2087..2087
        src/wafo/spectrum/models.py on lines 2092..2092
        src/wafo/spectrum/models.py on lines 2140..2140
        src/wafo/spectrum/models.py on lines 2150..2150
        src/wafo/spectrum/tests/test_specdata1d.py on lines 184..184
        src/wafo/stats/core.py on lines 1427..1427
        src/wafo/stats/core.py on lines 1446..1446
        src/wafo/tests/test_gaussian.py on lines 153..153
        src/wafo/tests/test_misc.py on lines 112..112
        src/wafo/tests/test_misc.py on lines 389..389
        src/wafo/tests/test_misc.py on lines 452..452
        src/wafo/tests/test_misc.py on lines 510..510
        src/wafo/tests/test_misc.py on lines 520..520
        src/wafo/tests/test_misc.py on lines 530..530
        src/wafo/tests/test_misc.py on lines 535..535
        src/wafo/tests/test_misc.py on lines 545..545
        src/wafo/tests/test_misc.py on lines 555..555
        src/wafo/tests/test_misc.py on lines 568..568

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 23 locations. Consider refactoring.
        Open

            pp = interpolate.ppform.fromspline(*tck0)  # @UndefinedVariable
        Severity: Major
        Found in src/wafo/interpolate.py and 22 other locations - About 45 mins to fix
        src/wafo/containers.py on lines 367..367
        src/wafo/covariance/core.py on lines 704..704
        src/wafo/covariance/estimation.py on lines 129..130
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 36..36
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 46..46
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 88..88
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 243..243
        src/wafo/interpolate.py on lines 1311..1311
        src/wafo/kdetools/kdetools.py on lines 451..451
        src/wafo/kdetools/kdetools.py on lines 493..493
        src/wafo/kdetools/kdetools.py on lines 722..722
        src/wafo/kdetools/kernels.py on lines 641..641
        src/wafo/kdetools/kernels.py on lines 801..801
        src/wafo/kdetools/kernels.py on lines 802..802
        src/wafo/kdetools/kernels.py on lines 886..886
        src/wafo/kdetools/kernels.py on lines 1001..1001
        src/wafo/kdetools/kernels.py on lines 1002..1002
        src/wafo/kdetools/kernels.py on lines 1105..1105
        src/wafo/kdetools/kernels.py on lines 1106..1106
        src/wafo/kdetools/kernels.py on lines 1232..1232
        src/wafo/kdetools/kernels.py on lines 1233..1233
        src/wafo/markov.py on lines 803..803

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 23 locations. Consider refactoring.
        Open

            self = interpolate.ppform.fromspline(*tck2)  # @UndefinedVariable
        Severity: Major
        Found in src/wafo/interpolate.py and 22 other locations - About 45 mins to fix
        src/wafo/containers.py on lines 367..367
        src/wafo/covariance/core.py on lines 704..704
        src/wafo/covariance/estimation.py on lines 129..130
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 36..36
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 46..46
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 88..88
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 243..243
        src/wafo/interpolate.py on lines 1297..1297
        src/wafo/kdetools/kdetools.py on lines 451..451
        src/wafo/kdetools/kdetools.py on lines 493..493
        src/wafo/kdetools/kdetools.py on lines 722..722
        src/wafo/kdetools/kernels.py on lines 641..641
        src/wafo/kdetools/kernels.py on lines 801..801
        src/wafo/kdetools/kernels.py on lines 802..802
        src/wafo/kdetools/kernels.py on lines 886..886
        src/wafo/kdetools/kernels.py on lines 1001..1001
        src/wafo/kdetools/kernels.py on lines 1002..1002
        src/wafo/kdetools/kernels.py on lines 1105..1105
        src/wafo/kdetools/kernels.py on lines 1106..1106
        src/wafo/kdetools/kernels.py on lines 1232..1232
        src/wafo/kdetools/kernels.py on lines 1233..1233
        src/wafo/markov.py on lines 803..803

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

                ddydx = diff(dydx, axis=0)
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 45 mins to fix
        src/wafo/kdetools/kdetools.py on lines 920..920
        src/wafo/kdetools/kdetools.py on lines 925..925
        src/wafo/kdetools/kdetools.py on lines 926..926
        src/wafo/kdetools/kernels.py on lines 642..642
        src/wafo/stats/core.py on lines 1382..1382
        src/wafo/tests/test_misc.py on lines 310..310

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            dy1 = (yp.take(idx) - sidx) * (xi - xidx)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 45 mins to fix
        src/wafo/objects.py on lines 276..276
        src/wafo/stats/_continuous_distns.py on lines 677..677
        src/wafo/stats/_continuous_distns.py on lines 2472..2472
        src/wafo/stats/_continuous_distns.py on lines 2835..2835

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            yp = slope_fun(x, y, dx, dydx, tension)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 45 mins to fix
        src/wafo/_misc_numba.py on lines 616..616
        src/wafo/gaussian.py on lines 382..382
        src/wafo/markov.py on lines 412..412
        src/wafo/stats/_distn_infrastructure.py on lines 95..95
        src/wafo/stats/core.py on lines 606..607

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[:size, -size:] = band - np.abs(zout[2 * size:size:-1, -size:] - band)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 249..249

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[-size:, :size] = band - np.abs(zout[-size:, 2 * size:size:-1] - band)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 246..246

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                        for k in range(-half_window, half_window + 1)])
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 267..267

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            w1 = 2 * hk[1:] + hk[:-1]
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 687..687

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            whmean = 1.0 / (w1 + w2) * (w1 / mk[1:] + w2 / mk[:-1])
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 688..688

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            w2 = hk[1:] + 2 * hk[:-1]
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 686..686

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                ind = np.arange(-size, size + 1, dtype=np.float)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 98..98

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                    A[:, i] = (dx ** exp[0]) * (dy ** exp[1])
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 45 mins to fix
        src/wafo/interpolate.py on lines 274..274

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 13.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 16 locations. Consider refactoring.
        Open

            x = np.linspace(-1, 3)
        Severity: Major
        Found in src/wafo/interpolate.py and 15 other locations - About 40 mins to fix
        src/wafo/demos.py on lines 135..136
        src/wafo/doc/tutorial_scripts/rainflow_example.py on lines 141..141
        src/wafo/kdetools/demo.py on lines 151..151
        src/wafo/spectrum/models.py on lines 2063..2063
        src/wafo/spectrum/models.py on lines 2069..2069
        src/wafo/spectrum/models.py on lines 2097..2097
        src/wafo/spectrum/models.py on lines 2098..2098
        src/wafo/spectrum/models.py on lines 2106..2106
        src/wafo/spectrum/models.py on lines 2110..2110
        src/wafo/spectrum/tests/test_models.py on lines 26..26
        src/wafo/spectrum/tests/test_specdata1d.py on lines 58..58
        src/wafo/stats/_continuous_distns.py on lines 8534..8534
        src/wafo/transform/models.py on lines 575..575
        src/wafo/transform/tests/test_trdata.py on lines 11..11
        src/wafo/wavemodels.py on lines 18..18

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 12.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

            def __init__(self, x, y, yp=None, method='parabola', monotone=False):
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 40 mins to fix
        src/wafo/interpolate.py on lines 993..993

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 12.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

            def __init__(self, x, y, yp=None, method='parabola', monotone=False):
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 40 mins to fix
        src/wafo/interpolate.py on lines 1006..1006

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 12.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            return np.concatenate((firstpart, rest))
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 40 mins to fix
        src/wafo/misc.py on lines 1689..1690

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 12.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 19 locations. Consider refactoring.
        Open

                if lin_extrap:
            self.linear_extrapolate(output=False)
        Severity: Major
        Found in src/wafo/interpolate.py and 18 other locations - About 35 mins to fix
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 38..38
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 49..49
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 61..61
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 80..80
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 91..91
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 94..94
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 103..103
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 123..123
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 130..130
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 138..138
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 150..150
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 154..154
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 180..180
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 205..205
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 214..214
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 232..232
        src/wafo/doc/tutorial_scripts/chapter5.py on lines 246..246
        src/wafo/kdetools/demo.py on lines 314..314

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 16 locations. Consider refactoring.
        Open

                yp[ii] = 0.0
        Severity: Major
        Found in src/wafo/interpolate.py and 15 other locations - About 35 mins to fix
        src/wafo/covariance/core.py on lines 408..408
        src/wafo/covariance/estimation.py on lines 137..137
        src/wafo/covariance/estimation.py on lines 164..164
        src/wafo/integrate_oscillating.py on lines 47..47
        src/wafo/integrate_oscillating.py on lines 401..401
        src/wafo/integrate_oscillating.py on lines 402..402
        src/wafo/misc.py on lines 857..857
        src/wafo/misc.py on lines 1718..1719
        src/wafo/misc.py on lines 1740..1740
        src/wafo/misc.py on lines 2009..2009
        src/wafo/sg_filter/_core.py on lines 257..257
        src/wafo/sg_filter/_core.py on lines 350..350
        src/wafo/spectrum/models.py on lines 1856..1856
        src/wafo/spectrum/models.py on lines 1874..1874
        src/wafo/spectrum/models.py on lines 1933..1933

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 14 locations. Consider refactoring.
        Open

                dx1 = 1. / dx
        Severity: Major
        Found in src/wafo/interpolate.py and 13 other locations - About 35 mins to fix
        src/wafo/padua.py on lines 277..277
        src/wafo/sg_filter/demos.py on lines 315..315
        src/wafo/spectrum/models.py on lines 1989..1989
        src/wafo/stats/_continuous_distns.py on lines 1323..1323
        src/wafo/stats/_continuous_distns.py on lines 1636..1636
        src/wafo/stats/_continuous_distns.py on lines 1644..1644
        src/wafo/stats/_continuous_distns.py on lines 1649..1649
        src/wafo/stats/_continuous_distns.py on lines 1654..1654
        src/wafo/stats/_continuous_distns.py on lines 3168..3168
        src/wafo/stats/_continuous_distns.py on lines 3175..3175
        src/wafo/stats/_continuous_distns.py on lines 3967..3968
        src/wafo/stats/_continuous_distns.py on lines 6326..6326
        src/wafo/stats/_continuous_distns.py on lines 7372..7372

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 10 locations. Consider refactoring.
        Open

                self._check(dx, n, ny)
        Severity: Major
        Found in src/wafo/interpolate.py and 9 other locations - About 35 mins to fix
        src/wafo/misc.py on lines 251..255
        src/wafo/sg_filter/_core.py on lines 1210..1210
        src/wafo/spectrum/core.py on lines 839..839
        src/wafo/spectrum/models.py on lines 606..606
        src/wafo/stats/_continuous_distns.py on lines 6171..6171
        src/wafo/stats/_continuous_distns.py on lines 6178..6178
        src/wafo/stats/_continuous_distns.py on lines 7916..7916
        src/wafo/stats/_continuous_distns.py on lines 7921..7921
        src/wafo/stats/estimation.py on lines 398..398

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 7 locations. Consider refactoring.
        Open

            def _poly_coefs(self, y, dx, dydx, n, nd, p, D):
        Severity: Major
        Found in src/wafo/interpolate.py and 6 other locations - About 35 mins to fix
        src/wafo/spectrum/core.py on lines 1856..1856
        src/wafo/spectrum/core.py on lines 2466..2466
        src/wafo/stats/_continuous_distns.py on lines 4447..4447
        src/wafo/stats/_continuous_distns.py on lines 4451..4451
        src/wafo/stats/_continuous_distns.py on lines 4455..4455
        src/wafo/stats/_continuous_distns.py on lines 4464..4464

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            plt.subplot(1, 2, 1)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 35 mins to fix
        src/wafo/doc/tutorial_scripts/chapter4.py on lines 44..44
        src/wafo/doc/tutorial_scripts/chapter4.py on lines 46..46
        src/wafo/interpolate.py on lines 1166..1166
        src/wafo/tests/test_integrate_oscillating.py on lines 357..357
        src/wafo/tests/test_integrate_oscillating.py on lines 367..367

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 6 locations. Consider refactoring.
        Open

            plt.subplot(1, 2, 2)
        Severity: Major
        Found in src/wafo/interpolate.py and 5 other locations - About 35 mins to fix
        src/wafo/doc/tutorial_scripts/chapter4.py on lines 44..44
        src/wafo/doc/tutorial_scripts/chapter4.py on lines 46..46
        src/wafo/interpolate.py on lines 1163..1163
        src/wafo/tests/test_integrate_oscillating.py on lines 357..357
        src/wafo/tests/test_integrate_oscillating.py on lines 367..367

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                    return PPform(newcoefs, newbreaks, a=-inf, b=inf)
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 35 mins to fix
        src/wafo/kdetools/demo.py on lines 259..259
        src/wafo/kdetools/demo.py on lines 263..263
        src/wafo/kdetools/kdetools.py on lines 923..923
        src/wafo/kdetools/kdetools.py on lines 928..929

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Identical blocks of code found in 2 locations. Consider refactoring.
        Open

                zout[size:-size, :size] = band - np.abs(z[:, size:0:-1] - band)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 35 mins to fix
        src/wafo/interpolate.py on lines 240..240

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

            dk[1:-1][~condition] = 1.0 / whmean[~condition]
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 35 mins to fix
        src/wafo/interpolate.py on lines 344..344
        src/wafo/stats/_continuous_distns.py on lines 3991..3991
        src/wafo/stats/_continuous_distns.py on lines 3991..3991
        src/wafo/stats/_continuous_distns.py on lines 3991..3991

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 5 locations. Consider refactoring.
        Open

                res[~mask] = self.fill
        Severity: Major
        Found in src/wafo/interpolate.py and 4 other locations - About 35 mins to fix
        src/wafo/interpolate.py on lines 692..692
        src/wafo/stats/_continuous_distns.py on lines 3991..3991
        src/wafo/stats/_continuous_distns.py on lines 3991..3991
        src/wafo/stats/_continuous_distns.py on lines 3991..3991

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

            vi = interp3(x, y, z, v, xi, yi, zi)
        Severity: Minor
        Found in src/wafo/interpolate.py and 2 other locations - About 35 mins to fix
        src/wafo/kdetools/gridding.py on lines 358..358
        src/wafo/sg_filter/_core.py on lines 713..713

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 3 locations. Consider refactoring.
        Open

                nd = np.int64(prod(szy[:-1]))
        Severity: Minor
        Found in src/wafo/interpolate.py and 2 other locations - About 35 mins to fix
        src/wafo/gaussian.py on lines 392..392
        src/wafo/stats/_distn_infrastructure.py on lines 152..152

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                ii, = (dydx == 0.0).nonzero()
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 35 mins to fix
        src/wafo/kdetools/kdetools.py on lines 992..992

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

                indices_to_fix, = (dist > 9.0).nonzero()
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 35 mins to fix
        src/wafo/wave_theory/dispersion_relation.py on lines 152..152

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            x = linspace(-1, 3, 20)
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 35 mins to fix
        src/wafo/tests/test_objects.py on lines 160..160

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 11.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            def __init__(self, x, y, yp=None, method='Catmull-Rom'):
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 30 mins to fix
        src/wafo/interpolate.py on lines 1123..1123

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 10.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Similar blocks of code found in 2 locations. Consider refactoring.
        Open

            def __init__(self, x, y, yp=None, method='secant'):
        Severity: Minor
        Found in src/wafo/interpolate.py and 1 other location - About 30 mins to fix
        src/wafo/interpolate.py on lines 1021..1021

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 10.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        There are no issues that match your filters.

        Category
        Status