Sign upLogin

wafo-project/pywafo

View on GitHub
Star
src/wafo/kdetools/kdetools.py

Summary

Maintainability
F
3 wks
Test Coverage

_KDE has 25 functions (exceeds 20 allowed). Consider refactoring.
Open

class _KDE(object):

    def __init__(self, data, kernel=None, xmin=None, xmax=None):
        self.dataset = data
        self.xmin = xmin
Severity: Minor
Found in src/wafo/kdetools/kdetools.py - About 2 hrs to fix

    Function __init__ has 14 arguments (exceeds 7 allowed). Consider refactoring.
    Open

        def __init__(self, data, y, method='beta', a=0.05, b=0.05, p=0, hs_e=None,
    Severity: Major
    Found in src/wafo/kdetools/kdetools.py - About 1 hr to fix

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

          def prb_smoothed(self, prb_e, hs, alpha=0.05, color='r', label=''):
        """Return smoothed binomial probability.

        Parameters
        ----------
      Severity: Minor
      Found in src/wafo/kdetools/kdetools.py - About 1 hr to fix

        Function __init__ has 10 arguments (exceeds 7 allowed). Consider refactoring.
        Open

            def __init__(self, data, y, p=0, hs=None, kernel=None, alpha=0.0,
        Severity: Major
        Found in src/wafo/kdetools/kdetools.py - About 50 mins to fix

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

              def __init__(self, data, hs=None, kernel=None, alpha=0.0,
          Severity: Major
          Found in src/wafo/kdetools/kdetools.py - About 35 mins to fix

            Method "__init__" has 11 parameters, which is greater than the 7 authorized.
            Open

                def __init__(self, data, y, p=0, hs=None, kernel=None, alpha=0.0,
                 xmin=None, xmax=None, inc=128, L2=None):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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):
    ...

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

                def __init__(self, data, hs=None, kernel=None, alpha=0.0, xmin=None,
                 xmax=None, inc=512):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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):
    ...

            Method "__init__" has 9 parameters, which is greater than the 7 authorized.
            Open

                def __init__(self, data, hs=None, kernel=None, alpha=0.0,
                 xmin=None, xmax=None, inc=512, L2=None):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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):
    ...

            Method "__init__" has 15 parameters, which is greater than the 7 authorized.
            Open

                def __init__(self, data, y, method='beta', a=0.05, b=0.05, p=0, hs_e=None,
                 hs=None, kernel=None, alpha=0.0, xmin=None, xmax=None,
                 inc=128, L2=None):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

            # def _logitinv(x):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

            # _REALMIN = np.finfo(float).min
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

            # from abc import ABCMeta, abstractmethod
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

                    # hx = np.median(np.abs(x-np.median(x)))/0.6745*(4.0/(3*n))**0.2
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

                        # hy = 4*hx
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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

                        # hy = np.median(np.abs(y-np.mean(y)))/0.6745*(4.0/(3*n))**0.2
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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"

            TODO found
            Open

                    t0 = grdfun(*args, r=0, y=self.y)  # TODO: Check accuracy. Culprit fft/ifft?
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py by fixme

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

                    try:
            c_levels = qlevels(wdata.data, p=p_levels)
            wdata.clevels = c_levels
            wdata.plevels = p_levels
        except ValueError as e:
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 4 hrs to fix
            src/wafo/wavemodels.py on lines 233..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 62.

            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 eval_grid_fast(self, *args, **kwds):
        self._grdfun = self.tkde.eval_grid_fast
        return self.tkde.eval_grid_fun(self._eval_gridfun, *args, **kwds)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 2 hrs to fix
            src/wafo/kdetools/kdetools.py on lines 907..909

            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 34.

            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 eval_grid(self, *args, **kwds):
        self._grdfun = self.tkde.eval_grid
        return self.tkde.eval_grid_fun(self._eval_gridfun, *args, **kwds)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 2 hrs to fix
            src/wafo/kdetools/kdetools.py on lines 903..905

            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 34.

            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

                    txmin = np.ravel(self._transform(np.reshape(self.xmin, (-1, 1))))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 2 hrs to fix
            src/wafo/kdetools/kdetools.py on lines 359..359

            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

                    txmax = np.ravel(self._transform(np.reshape(self.xmax, (-1, 1))))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 2 hrs to fix
            src/wafo/kdetools/kdetools.py on lines 358..358

            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

                    p_levels = np.r_[10:90:20, 95, 99, 99.9]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 2 hrs to fix
            src/wafo/wavemodels.py on lines 232..232

            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

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

                    L2 = np.atleast_1d(self.L2) * np.ones(self.d)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 365..365
            src/wafo/kdetools/kdetools.py on lines 389..389
            src/wafo/kdetools/kdetools.py on lines 412..412

            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 27.

            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 4 locations. Consider refactoring.
            Open

                    L2 = np.atleast_1d(self.L2) * np.ones(self.d)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 365..365
            src/wafo/kdetools/kdetools.py on lines 389..389
            src/wafo/kdetools/kdetools.py on lines 400..400

            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 27.

            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 4 locations. Consider refactoring.
            Open

                        L2 = np.atleast_1d(self.L2) * np.ones(self.d)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 389..389
            src/wafo/kdetools/kdetools.py on lines 400..400
            src/wafo/kdetools/kdetools.py on lines 412..412

            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 27.

            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 4 locations. Consider refactoring.
            Open

                    L2 = np.atleast_1d(self.L2) * np.ones(self.d)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 365..365
            src/wafo/kdetools/kdetools.py on lines 400..400
            src/wafo/kdetools/kdetools.py on lines 412..412

            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 27.

            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

                    self._xmax = self._check_xmax(xmax * np.ones(self.d))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 111..111

            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 27.

            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

                    self._xmin = self._check_xmin(xmin * np.ones(self.d))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 125..125

            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 27.

            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

                    if (len(h.shape) == 1) or (self.d == 1):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 621..621

            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 26.

            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

                    if (len(h.shape) == 1) or (self.d == 1):
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 627..627

            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 26.

            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.log(pc) - np.log1p(-pc)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/core.py on lines 756..757

            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 7 locations. Consider refactoring.
            Open

            def _assert_warn(cond, msg):
    if not cond:
        warnings.warn(msg)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 6 other locations - About 1 hr to fix
            src/wafo/integrate.py on lines 29..31
            src/wafo/integrate_oscillating.py on lines 30..32
            src/wafo/kdetools/kernels.py on lines 27..29
            src/wafo/stats/estimation.py on lines 46..48
            src/wafo/transform/models.py on lines 43..45
            src/wafo/wave_theory/dispersion_relation.py on lines 22..24

            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 2 locations. Consider refactoring.
            Open

                def eval_grid(self, *args, **kwds):
        """Evaluate the estimated pdf on a grid.

        Parameters
        ----------
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 130..148

            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 2 locations. Consider refactoring.
            Open

                def eval_grid_fast(self, *args, **kwds):
        """Evaluate the estimated pdf on a grid using fft.

        Parameters
        ----------
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 153..171

            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 16 locations. Consider refactoring.
            Open

                    dx_e = x_e[1] - x_e[0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 1 hr to fix
            src/wafo/covariance/estimation.py on lines 28..28
            src/wafo/covariance/estimation.py on lines 30..30
            src/wafo/kdetools/tests/test_gridding.py on lines 19..19
            src/wafo/kdetools/tests/test_gridding.py on lines 34..34
            src/wafo/kdetools/tests/test_gridding.py on lines 53..53
            src/wafo/kdetools/tests/test_gridding.py on lines 77..77
            src/wafo/misc.py on lines 2465..2465
            src/wafo/misc.py on lines 2541..2541
            src/wafo/objects.py on lines 1348..1348
            src/wafo/objects.py on lines 1350..1350
            src/wafo/sg_filter/demos.py on lines 47..47
            src/wafo/spectrum/core.py on lines 1274..1274
            src/wafo/spectrum/core.py on lines 1289..1289
            src/wafo/spectrum/core.py on lines 1406..1406
            src/wafo/spectrum/core.py on lines 1712..1712

            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

                        g = np.exp(np.mean(np.log(f)))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/padua.py on lines 412..412

            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/kdetools/kdetools.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/interpolate.py on lines 17..19
            src/wafo/kdetools/gridding.py on lines 13..15
            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

                    if xmax is not None:
            sxmax = np.maximum(xmax, sxmax)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 201..202

            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

                    self.tkde = TKDE(data, hs=hs, kernel=kernel,
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/objects.py on lines 1402..1402

            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

                    if xmin is not None:
            sxmin = np.minimum(xmin, sxmin)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 205..206

            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 4 locations. Consider refactoring.
            Open

                    if xi is None:
            xi = self.get_grid(hs_e)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/objects.py on lines 348..349
            src/wafo/sg_filter/demos.py on lines 120..121
            src/wafo/stats/estimation.py on lines 298..299

            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

                @property
    def d(self):
        return self.dataset.shape[0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 87..89

            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

                @property
    def n(self):
        return self.dataset.shape[1]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 91..93

            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

                @hs.setter
    def hs(self, hs):
        self.tkde.hs = hs
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 373..375

            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 2 locations. Consider refactoring.
            Open

                @inc.setter
    def inc(self, inc):
        self.tkde.inc = inc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 381..383

            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 3 locations. Consider refactoring.
            Open

                                   st.beta.isf(alpha / 2, n * p + a, n * (1 - p) + b))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 1051..1051
            src/wafo/stats/_continuous_distns.py on lines 8346..8346

            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

                        pdf *= np.where(v2 == 1, 1, points[i] ** (v2 - 1) * factor)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/_continuous_distns.py on lines 3954..3954

            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

                    CI = np.vstack(self.prb_ci(c, prb, alpha))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/_continuous_distns.py on lines 3922..3922

            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

                    k = (dp_s[:-1] != dp_s[1:]).sum()  # numpeaks
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/interpolate.py on lines 684..684

            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

                    xmin, xmax = x.min(), x.max()
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/markov.py on lines 494..494

            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

                    z0 = -_invnorm(alpha / 2)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/core.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 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

                        t1 = grdfun(*args, r=1, y=self.y)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 921..921

            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

                    t0 = grdfun(*args, r=0, y=self.y)  # TODO: Check accuracy. Culprit fft/ifft?
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 927..927

            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

                @inc.setter
    def inc(self, inc):
        # pylint: disable=attribute-defined-outside-init
        self._inc = inc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/sg_filter/_core.py on lines 538..540

            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

                    dp_s = np.sign(np.diff(p_s))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 14 other locations - About 1 hr to fix
            src/wafo/interpolate.py on lines 90..90
            src/wafo/interpolate.py on lines 91..91
            src/wafo/kdetools/kdetools.py on lines 1097..1100
            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

                    if np.any(y == 1):
            c0 = gridcount(x[y == 1], xi)  # + self.a # count success
        else:
            c0 = np.zeros(np.shape(xi))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 14 other locations - About 1 hr to fix
            src/wafo/interpolate.py on lines 90..90
            src/wafo/interpolate.py on lines 91..91
            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

                    aicc = np.zeros(np.size(hsvec))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 14 other locations - About 1 hr to fix
            src/wafo/interpolate.py on lines 90..90
            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/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 9 locations. Consider refactoring.
            Open

                    if hs_e is None:
            hs_e = self.hs_e
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 8 other locations - About 1 hr to fix
            src/wafo/kdetools/gridding.py on lines 53..54
            src/wafo/kdetools/gridding.py on lines 203..204
            src/wafo/kdetools/gridding.py on lines 205..206
            src/wafo/spectrum/core.py on lines 3094..3095
            src/wafo/spectrum/models.py on lines 804..805
            src/wafo/spectrum/models.py on lines 806..807
            src/wafo/transform/estimation.py on lines 232..233
            src/wafo/transform/estimation.py on lines 234..235

            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

                        hs2 = self._get_max_smoothing('hos')[0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 1 hr to fix
            src/wafo/doc/tutorial_scripts/chapter2.py on lines 305..305
            src/wafo/kdetools/kdetools.py on lines 967..967
            src/wafo/spectrum/core.py on lines 1075..1075
            src/wafo/spectrum/core.py on lines 1076..1076

            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

                        hs1 = self._get_max_smoothing('hste')[0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 1 hr to fix
            src/wafo/doc/tutorial_scripts/chapter2.py on lines 305..305
            src/wafo/kdetools/kdetools.py on lines 968..968
            src/wafo/spectrum/core.py on lines 1075..1075
            src/wafo/spectrum/core.py on lines 1076..1076

            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

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

                    y_d_lambda = y / lambda_ ** d
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 777..777

            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

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

            if __name__ == '__main__':
    test_docstrings(__file__)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kernels.py on lines 1318..1319

            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

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

                    y_d_lambda = y / lambda_ ** d
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 763..763

            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

                    ni = max(2 * int((xmax - xmin) / hs_e) + 3, 5)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 1 hr to fix
            src/wafo/stats/_distn_infrastructure.py on lines 144..144
            src/wafo/stats/estimation.py on lines 106..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 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

                    nz02 = n / z0 ** 2.
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 1 hr to fix
            src/wafo/spectrum/core.py on lines 3590..3590
            src/wafo/stats/_continuous_distns.py on lines 6324..6324

            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

                        inv_hs = np.diag(1.0 / h)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 1 hr to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 185..185
            src/wafo/stats/_continuous_distns.py on lines 3687..3687

            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

                        xmax = [max(t) for t in targs0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 440..440

            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

                        hs2 = get_smoothing(x[y == 1])
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/misc.py on lines 2059..2059

            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

                        self._lambda = (f / g) ** (-alpha)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/_continuous_distns.py on lines 8171..8171

            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

                        xmin = [min(t) for t in targs0]
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 441..441

            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

                    super(KDE, self).__init__(data, kernel, xmin, xmax)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 355..355

            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

                    super(TKDE, self).__init__(data, kernel, xmin, xmax)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/kdetools/kdetools.py on lines 607..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 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

                    if prb_e is None:
            prb_e = self.prb_empirical(alpha=alpha, color=color)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 1 hr to fix
            src/wafo/objects.py on lines 1509..1509
            src/wafo/spectrum/core.py on lines 3264..3264
            src/wafo/spectrum/core.py on lines 4376..4376

            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

                    c = gridcount(self.dataset, X, y=y)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/objects.py on lines 1213..1213

            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

                        args.append(np.linspace(sxmin[i], sxmax[i], inc))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 1 hr to fix
            src/wafo/stats/core.py on lines 453..453

            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 10 locations. Consider refactoring.
            Open

                    targs = self._transform(list(args))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 9 other locations - About 55 mins to fix
            src/wafo/kdetools/gridding.py on lines 66..66
            src/wafo/kdetools/kdetools.py on lines 439..439
            src/wafo/markov.py on lines 120..120
            src/wafo/markov.py on lines 345..345
            src/wafo/markov.py on lines 367..367
            src/wafo/markov.py on lines 611..611
            src/wafo/sg_filter/demos.py on lines 281..281
            src/wafo/stats/core.py on lines 438..439
            src/wafo/stats/core.py on lines 584..585

            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 10 locations. Consider refactoring.
            Open

                        targs0 = self._transform(list(args))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 9 other locations - About 55 mins to fix
            src/wafo/kdetools/gridding.py on lines 66..66
            src/wafo/kdetools/kdetools.py on lines 463..463
            src/wafo/markov.py on lines 120..120
            src/wafo/markov.py on lines 345..345
            src/wafo/markov.py on lines 367..367
            src/wafo/markov.py on lines 611..611
            src/wafo/sg_filter/demos.py on lines 281..281
            src/wafo/stats/core.py on lines 438..439
            src/wafo/stats/core.py on lines 584..585

            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

            def _invnorm(q):
    return special.ndtri(q)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 8 other locations - About 55 mins to fix
            src/wafo/stats/_continuous_distns.py on lines 259..260
            src/wafo/stats/_continuous_distns.py on lines 263..264
            src/wafo/stats/_continuous_distns.py on lines 267..268
            src/wafo/stats/core.py on lines 54..55
            src/wafo/stats/core.py on lines 58..59
            src/wafo/tests/test_integrate_oscillating.py on lines 196..197
            src/wafo/tests/test_integrate_oscillating.py on lines 199..200
            src/wafo/tests/test_integrate_oscillating.py on lines 278..279

            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

                        f = self.prb_smoothed(prb_e, hi, alpha, color, label)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 1191..1191
            src/wafo/transform/models.py on lines 537..537
            src/wafo/transform/models.py on lines 538..538
            src/wafo/transform/models.py on lines 546..546
            src/wafo/transform/models.py on lines 547..547

            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

                    prb_best = self.prb_smoothed(prb_e, hs_best, alpha, color, label)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 1194..1194
            src/wafo/transform/models.py on lines 537..537
            src/wafo/transform/models.py on lines 538..538
            src/wafo/transform/models.py on lines 546..546
            src/wafo/transform/models.py on lines 547..547

            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 5 locations. Consider refactoring.
            Open

                        hs_e = sqrt(hs1 * hs2)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 999..999
            src/wafo/sg_filter/_core.py on lines 464..464
            src/wafo/sg_filter/demos.py on lines 126..126
            src/wafo/spectrum/models.py on lines 1709..1709

            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 5 locations. Consider refactoring.
            Open

                    self._lambda = np.ones(self.n)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 55 mins to fix
            src/wafo/objects.py on lines 1117..1121
            src/wafo/objects.py on lines 1122..1122
            src/wafo/transform/core.py on lines 189..191
            src/wafo/transform/estimation.py on lines 339..339

            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 5 locations. Consider refactoring.
            Open

                    hopt = sqrt(hs1 * hs2)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 969..969
            src/wafo/sg_filter/_core.py on lines 464..464
            src/wafo/sg_filter/demos.py on lines 126..126
            src/wafo/spectrum/models.py on lines 1709..1709

            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

                        inc = 2 ** nextpow2(inc)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 55 mins to fix
            src/wafo/covariance/core.py on lines 235..238
            src/wafo/covariance/estimation.py on lines 144..144
            src/wafo/spectrum/core.py on lines 925..928

            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

                    if self.L2 is None:
            return pdf
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 386..387
            src/wafo/kdetools/kdetools.py on lines 397..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 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

                    if self.L2 is None:
            return points  # default no transformation
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 397..398
            src/wafo/kdetools/kdetools.py on lines 409..410

            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

                        amin = self.dataset.min(axis=-1)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/tests/test_objects.py on lines 26..26
            src/wafo/tests/test_objects.py on lines 36..36

            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

                    if self.L2 is None:
            return tpoints  # default no transformation
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 386..387
            src/wafo/kdetools/kdetools.py on lines 409..410

            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

                @property
    def hs(self):
        return self.tkde.hs
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 369..371
            src/wafo/kdetools/kernels.py on lines 561..563

            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

                @property
    def inc(self):
        return self.tkde.inc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 377..379
            src/wafo/kdetools/kernels.py on lines 561..563

            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

                    plo = xc - halfwidth.clip(max=1.0)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 116..116

            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

                    tf = self.tkde.eval_grid(*targs, **kwds)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 447..447

            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

                    _assert_warn((np.abs(np.diff(pdf)).max() < 10).all(), '''
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/tests/test_misc.py on lines 685..685

            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

                kernel = property(fget=lambda cls: cls.kreg.tkde.kernel)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 979..979

            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

                    iqr = iqrange(self.dataset, axis=-1)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/spectrum/tests/test_specdata1d.py on lines 81..81

            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

                    self._norm_factor = deth * self.n
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/spectrum/core.py on lines 1144..1144

            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

                    for i in range(self.d):
            points[i].shape = -1,
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 689..690

            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

                    for i in range(d):
            Xnc[i].shape = (-1,)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 424..425

            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

                        dxi = points[:, i, np.newaxis] - data
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 766..766

            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

                        dxi = points - data[:, i, np.newaxis]
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 780..780

            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

                hs = property(fset=_set_smoothing, fget=lambda cls: cls.kreg.tkde.hs)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 978..978

            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

                        f = self.tkde.eval_grid_fast(*args, **kwds)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 464..464

            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

                            linalg.norm(((logit_p_e - logit_pup).clip(min=0) -
                             (logit_p_e - logit_plo).clip(max=0))/sigmai, ord=s2))  # empirical p_e outside of [plo, pup]
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 55 mins to fix
            src/wafo/kdetools/kdetools.py on lines 1165..1165

            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 5 locations. Consider refactoring.
            Open

                        _assert(0 < determinant,
                    'bandwidth matrix h must be positive definit!')
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 50 mins to fix
            src/wafo/integrate.py on lines 471..471
            src/wafo/kdetools/kernels.py on lines 277..277
            src/wafo/misc.py on lines 850..850
            src/wafo/sg_filter/_core.py on lines 1125..1125

            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

                    kw = self._kernel_weights(Xn, dx, d, inc)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 50 mins to fix
            src/wafo/integrate.py on lines 1016..1016
            src/wafo/interpolate.py on lines 578..578
            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 3 locations. Consider refactoring.
            Open

                        _tau, tau = self.kernel.effective_support()
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 50 mins to fix
            src/wafo/stats/estimation.py on lines 758..758
            src/wafo/stats/estimation.py on lines 763..763

            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

                        targs = self.tkde.get_args(xmin, xmax)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 50 mins to fix
            src/wafo/f2py_tools.py on lines 33..33
            build_package.py on lines 35..35

            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

                    Xn = np.dot(self._inv_hs, Xnc)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 50 mins to fix
            src/wafo/dctpack.py on lines 165..168
            src/wafo/sg_filter/_core.py on lines 1040..1040

            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

                    prb_s.data = prb_s.data.clip(min=0, max=1.0)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 50 mins to fix
            src/wafo/kdetools/demo.py on lines 66..66

            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

                        xmin = np.where(L2 != 1, np.maximum(xmin, amin / 100.0), xmin)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 50 mins to fix
            src/wafo/kdetools/kernels.py on lines 648..648

            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 23 locations. Consider refactoring.
            Open

                    kw = np.fft.ifftshift(kw)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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/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/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

                    tf = self.tkde.eval_points(tpoints)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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/interpolate.py on lines 1311..1311
            src/wafo/kdetools/kdetools.py on lines 451..451
            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

                    tf = self.tkde.eval_grid_fast(*targs)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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/interpolate.py on lines 1311..1311
            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 16 locations. Consider refactoring.
            Open

                @property
    def xmin(self):
        return self._xmin
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def alpha(self):
        return self._alpha
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def inc(self):
        return self._inc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                    Xnc = self._make_flat_grid(dx, d, inc)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.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/interpolate.py on lines 577..577
            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 16 locations. Consider refactoring.
            Open

                @property
    def dataset(self):
        return self._dataset
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def xmax(self):
        return self._xmax
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def hs(self):
        return self._hs
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def hs_e(self):
        return self._hs_e
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 651..653
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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

                @property
    def inc(self):
        return self._inc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 15 other locations - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 69..71
            src/wafo/kdetools/kdetools.py on lines 78..80
            src/wafo/kdetools/kdetools.py on lines 102..104
            src/wafo/kdetools/kdetools.py on lines 116..118
            src/wafo/kdetools/kdetools.py on lines 637..639
            src/wafo/kdetools/kdetools.py on lines 666..668
            src/wafo/kdetools/kdetools.py on lines 960..962
            src/wafo/kdetools/kernels.py on lines 272..274
            src/wafo/sg_filter/_core.py on lines 935..937
            src/wafo/sg_filter/_core.py on lines 947..949
            src/wafo/sg_filter/_core.py on lines 959..961
            src/wafo/sg_filter/_core.py on lines 971..973
            src/wafo/spectrum/core.py on lines 719..721
            src/wafo/spectrum/models.py on lines 1524..1526
            src/wafo/transform/models.py on lines 154..156

            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 12 locations. Consider refactoring.
            Open

            _REALMAX = np.finfo(float).max
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 11 other locations - About 45 mins to fix
            src/wafo/integrate.py on lines 16..16
            src/wafo/kdetools/kdetools.py on lines 30..30
            src/wafo/kdetools/kdetools.py on lines 33..33
            src/wafo/kdetools/kdetools.py on lines 426..426
            src/wafo/sg_filter/_core.py on lines 1138..1138
            src/wafo/spectrum/core.py on lines 51..51
            src/wafo/spectrum/core.py on lines 52..52
            src/wafo/stats/core.py on lines 18..18
            src/wafo/stats/core.py on lines 1269..1269
            src/wafo/tests/test_integrate_oscillating.py on lines 19..19
            src/wafo/transform/models.py on lines 17..17

            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 12 locations. Consider refactoring.
            Open

                    points = np.asarray(points).T
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 11 other locations - About 45 mins to fix
            src/wafo/integrate.py on lines 16..16
            src/wafo/kdetools/kdetools.py on lines 30..30
            src/wafo/kdetools/kdetools.py on lines 32..32
            src/wafo/kdetools/kdetools.py on lines 33..33
            src/wafo/sg_filter/_core.py on lines 1138..1138
            src/wafo/spectrum/core.py on lines 51..51
            src/wafo/spectrum/core.py on lines 52..52
            src/wafo/stats/core.py on lines 18..18
            src/wafo/stats/core.py on lines 1269..1269
            src/wafo/tests/test_integrate_oscillating.py on lines 19..19
            src/wafo/transform/models.py on lines 17..17

            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 3 locations. Consider refactoring.
            Open

                                   st.beta.isf(1 - alpha / 2, n * p + a, n * (1 - p) + b))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 45 mins to fix
            src/wafo/objects.py on lines 1538..1538
            src/wafo/stats/core.py on lines 380..380

            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 12 locations. Consider refactoring.
            Open

            _EPS = np.finfo(float).eps
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 11 other locations - About 45 mins to fix
            src/wafo/integrate.py on lines 16..16
            src/wafo/kdetools/kdetools.py on lines 30..30
            src/wafo/kdetools/kdetools.py on lines 32..32
            src/wafo/kdetools/kdetools.py on lines 426..426
            src/wafo/sg_filter/_core.py on lines 1138..1138
            src/wafo/spectrum/core.py on lines 51..51
            src/wafo/spectrum/core.py on lines 52..52
            src/wafo/stats/core.py on lines 18..18
            src/wafo/stats/core.py on lines 1269..1269
            src/wafo/tests/test_integrate_oscillating.py on lines 19..19
            src/wafo/transform/models.py on lines 17..17

            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 12 locations. Consider refactoring.
            Open

            _TINY = np.finfo(float).tiny
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 11 other locations - About 45 mins to fix
            src/wafo/integrate.py on lines 16..16
            src/wafo/kdetools/kdetools.py on lines 32..32
            src/wafo/kdetools/kdetools.py on lines 33..33
            src/wafo/kdetools/kdetools.py on lines 426..426
            src/wafo/sg_filter/_core.py on lines 1138..1138
            src/wafo/spectrum/core.py on lines 51..51
            src/wafo/spectrum/core.py on lines 52..52
            src/wafo/stats/core.py on lines 18..18
            src/wafo/stats/core.py on lines 1269..1269
            src/wafo/tests/test_integrate_oscillating.py on lines 19..19
            src/wafo/transform/models.py on lines 17..17

            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

                    s0 = grdfun(*args, r=0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 6 other locations - About 45 mins to fix
            src/wafo/interpolate.py on lines 660..660
            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 7 locations. Consider refactoring.
            Open

                        s2 = grdfun(*args, r=2)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 6 other locations - About 45 mins to fix
            src/wafo/interpolate.py on lines 660..660
            src/wafo/kdetools/kdetools.py on lines 920..920
            src/wafo/kdetools/kdetools.py on lines 925..925
            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 7 locations. Consider refactoring.
            Open

                        s1 = grdfun(*args, r=1)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 6 other locations - About 45 mins to fix
            src/wafo/interpolate.py on lines 660..660
            src/wafo/kdetools/kdetools.py on lines 920..920
            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

                    result = np.zeros((m,))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 45 mins to fix
            src/wafo/integrate_oscillating.py on lines 385..385
            src/wafo/kdetools/gridding.py on lines 234..234
            src/wafo/kdetools/kdetools.py on lines 778..778
            src/wafo/stats/core.py on lines 957..957

            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 4 locations. Consider refactoring.
            Open

                    shape0 = grd[0].shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 45 mins to fix
            src/wafo/integrate.py on lines 989..989
            src/wafo/misc.py on lines 240..240
            src/wafo/misc.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 5 locations. Consider refactoring.
            Open

                        aicc[i] = f.aicc
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 45 mins to fix
            src/wafo/misc.py on lines 2108..2108
            src/wafo/stats/_continuous_distns.py on lines 3750..3750
            src/wafo/stats/core.py on lines 498..498
            src/wafo/stats/core.py on lines 537..537

            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

                    result = np.zeros((m,))
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 45 mins to fix
            src/wafo/integrate_oscillating.py on lines 385..385
            src/wafo/kdetools/gridding.py on lines 234..234
            src/wafo/kdetools/kdetools.py on lines 764..764
            src/wafo/stats/core.py on lines 957..957

            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 3 locations. Consider refactoring.
            Open

                    ind, = np.where(h <= 0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 45 mins to fix
            src/wafo/stats/_continuous_distns.py on lines 678..678
            src/wafo/stats/_continuous_distns.py on lines 5112..5112

            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

                    prb = np.where(c == 0, 0, c0 / (c + _TINY))  # assume prb==0 for c==0
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 45 mins to fix
            src/wafo/kdetools/kdetools.py on lines 923..923

            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

                        xyzrange = 8 * self.sigma
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 45 mins to fix
            src/wafo/gaussian.py on lines 303..303

            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

                        h[i] = get_default_hs(self.dataset[i])
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 45 mins to fix
            src/wafo/transform/estimation.py on lines 346..346

            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

                        return z[ix] * (z[ix] > 0.0)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 45 mins to fix
            src/wafo/gaussian.py on lines 941..941

            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

                    y = kwds.get('y', 1)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 40 mins to fix
            src/wafo/fig.py on lines 862..862
            src/wafo/kdetools/kdetools.py on lines 431..431
            src/wafo/kdetools/kdetools.py on lines 717..717
            src/wafo/kdetools/kdetools.py on lines 724..724
            src/wafo/kdetools/kdetools.py on lines 809..809

            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 6 locations. Consider refactoring.
            Open

                    y = kwds.get('y', 1.0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 40 mins to fix
            src/wafo/fig.py on lines 862..862
            src/wafo/kdetools/kdetools.py on lines 431..431
            src/wafo/kdetools/kdetools.py on lines 717..717
            src/wafo/kdetools/kdetools.py on lines 808..808
            src/wafo/kdetools/kdetools.py on lines 809..809

            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 6 locations. Consider refactoring.
            Open

                    r = kwds.get('r', 0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 40 mins to fix
            src/wafo/fig.py on lines 862..862
            src/wafo/kdetools/kdetools.py on lines 431..431
            src/wafo/kdetools/kdetools.py on lines 724..724
            src/wafo/kdetools/kdetools.py on lines 808..808
            src/wafo/kdetools/kdetools.py on lines 809..809

            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 6 locations. Consider refactoring.
            Open

                    r = kwds.get('r', 0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 40 mins to fix
            src/wafo/fig.py on lines 862..862
            src/wafo/kdetools/kdetools.py on lines 717..717
            src/wafo/kdetools/kdetools.py on lines 724..724
            src/wafo/kdetools/kdetools.py on lines 808..808
            src/wafo/kdetools/kdetools.py on lines 809..809

            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 6 locations. Consider refactoring.
            Open

                    r = kwds.get('r', 0)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 40 mins to fix
            src/wafo/fig.py on lines 862..862
            src/wafo/kdetools/kdetools.py on lines 431..431
            src/wafo/kdetools/kdetools.py on lines 717..717
            src/wafo/kdetools/kdetools.py on lines 724..724
            src/wafo/kdetools/kdetools.py on lines 808..808

            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 5 locations. Consider refactoring.
            Open

                    self.b = max(b, _TINY)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 40 mins to fix
            src/wafo/kdetools/kdetools.py on lines 952..952
            src/wafo/kdetools/kdetools.py on lines 1199..1199
            src/wafo/kdetools/kernels.py on lines 559..559
            src/wafo/spectrum/models.py on lines 543..544

            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 5 locations. Consider refactoring.
            Open

                    self.a = max(a, _TINY)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 40 mins to fix
            src/wafo/kdetools/kdetools.py on lines 953..953
            src/wafo/kdetools/kdetools.py on lines 1199..1199
            src/wafo/kdetools/kernels.py on lines 559..559
            src/wafo/spectrum/models.py on lines 543..544

            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 5 locations. Consider refactoring.
            Open

                    prb_best.score = PlotData(aicc, hsvec)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 40 mins to fix
            src/wafo/kdetools/kdetools.py on lines 952..952
            src/wafo/kdetools/kdetools.py on lines 953..953
            src/wafo/kdetools/kernels.py on lines 559..559
            src/wafo/spectrum/models.py on lines 543..544

            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 3 locations. Consider refactoring.
            Open

                    if fun is None:
            get_smoothing = self.kernel.get_smoothing
        else:
            get_smoothing = getattr(self.kernel, fun)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 40 mins to fix
            src/wafo/stats/estimation.py on lines 532..532
            src/wafo/stats/estimation.py on lines 941..941

            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

                    output = kwds.pop('output', 'value')
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 40 mins to fix
            src/wafo/containers.py on lines 197..197

            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

                        tdiff = np.dot(inv_hs, dxi / lambda_[np.newaxis, :])
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 40 mins to fix
            src/wafo/stats/estimation.py on lines 1292..1292

            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 self._interpolate(points, f, *args, **kwds)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 40 mins to fix
            src/wafo/containers.py on lines 426..426

            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

                    wdata = PlotData(f, args, **kwds2)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 40 mins to fix
            src/wafo/containers.py on lines 204..204

            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

                    prb_s.dataCI = np.vstack((plo, pup)).T
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 40 mins to fix
            src/wafo/stats/core.py on lines 1030..1030

            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 6 locations. Consider refactoring.
            Open

            __all__ = ['TKDE', 'KDE', 'test_docstrings', 'KRegression', 'BKRegression']
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 35 mins to fix
            src/wafo/conftest.py on lines 0..3
            src/wafo/kdetools/kernels.py on lines 19..19
            src/wafo/objects.py on lines 48..49
            src/wafo/stats/distributions.py on lines 256..256
            src/wafo/wave_theory/core.py on lines 10..10

            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

                @dataset.setter
    def dataset(self, data):
        # pylint: disable=attribute-defined-outside-init
        self._dataset = atleast_2d(data)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 35 mins to fix
            src/wafo/containers.py on lines 85..85
            src/wafo/containers.py on lines 259..260
            src/wafo/containers.py on lines 249..265
            src/wafo/stats/core.py on lines 1067..1067
            src/wafo/win32_utils.py on lines 80..80

            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

                    f = eval_grd(*args, **kwds)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 5 other locations - About 35 mins to fix
            src/wafo/containers.py on lines 366..366
            src/wafo/containers.py on lines 596..599
            src/wafo/containers.py on lines 615..615
            src/wafo/integrate.py on lines 1034..1034
            src/wafo/tests/test_misc.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 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 (t0 / (s0 + _TINY)).clip(min=-_REALMAX, max=_REALMAX)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 35 mins to fix
            src/wafo/interpolate.py on lines 408..408
            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 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

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

                        return ((s2 * t0 - s1 * t1) /
                    (s2 * s0 - s1 ** 2)).clip(min=-_REALMAX, max=_REALMAX)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 4 other locations - About 35 mins to fix
            src/wafo/interpolate.py on lines 408..408
            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

            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 4 locations. Consider refactoring.
            Open

                    kwds2 = dict(title=titlestr)
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 35 mins to fix
            src/wafo/kdetools/kernels.py on lines 388..388
            src/wafo/kdetools/kernels.py on lines 398..398
            src/wafo/stats/tests/test_fit.py on lines 65..65

            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

                        if f.aicc <= prb_best.aicc:
                prb_best = f
                hs_best = hi
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 35 mins to fix
            src/wafo/stats/_distn_infrastructure.py on lines 248..250
            src/wafo/stats/estimation.py on lines 461..463

            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

                    return result / self.norm_factor
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 35 mins to fix
            src/wafo/kdetools/kdetools.py on lines 769..769
            src/wafo/stats/_continuous_distns.py on lines 4622..4622

            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

                    return result / self.norm_factor
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 2 other locations - About 35 mins to fix
            src/wafo/kdetools/kdetools.py on lines 783..783
            src/wafo/stats/_continuous_distns.py on lines 4622..4622

            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

                    if self.L2 is None:
            return self.tkde.eval_points(points)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/misc.py on lines 110..111

            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

                    s1, s2 = 1, 1
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/stats/_continuous_distns.py on lines 3924..3931

            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

                    c_s = self.kreg.tkde.eval_grid_fast(x_s) * dx_e * n
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/integrate.py on lines 1334..1334

            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

                    return self._eval_points(points, **kwds)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/kdetools/kdetools.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 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

                    return self._make_object(f, **kwds)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/kdetools/kdetools.py on lines 256..256

            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, data, kernel=None, xmin=None, xmax=None):
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/stats/core.py on lines 915..915

            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

                    plo, pup = self.prb_ci(c_s, prb_s.data, alpha)
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/stats/estimation.py on lines 349..349

            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

                    if (y == 1).any():
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 35 mins to fix
            src/wafo/interpolate.py on lines 783..783

            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 25 locations. Consider refactoring.
            Open

                    d, m = points.shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 24 other locations - About 30 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 187..187
            src/wafo/gaussian.py on lines 335..335
            src/wafo/gaussian.py on lines 717..717
            src/wafo/graphutil.py on lines 238..238
            src/wafo/kdetools/gridding.py on lines 230..230
            src/wafo/kdetools/gridding.py on lines 341..341
            src/wafo/kdetools/kdetools.py on lines 226..226
            src/wafo/kdetools/kdetools.py on lines 709..709
            src/wafo/kdetools/kdetools.py on lines 773..773
            src/wafo/kdetools/kdetools.py on lines 805..805
            src/wafo/kdetools/kernels.py on lines 755..755
            src/wafo/kdetools/kernels.py on lines 799..799
            src/wafo/kdetools/kernels.py on lines 885..885
            src/wafo/kdetools/kernels.py on lines 999..999
            src/wafo/kdetools/kernels.py on lines 1103..1103
            src/wafo/kdetools/kernels.py on lines 1230..1230
            src/wafo/misc.py on lines 1188..1188
            src/wafo/misc.py on lines 2885..2885
            src/wafo/spectrum/core.py on lines 4114..4114
            src/wafo/stats/core.py on lines 951..951
            src/wafo/stats/core.py on lines 952..952
            src/wafo/stats/core.py on lines 953..953
            src/wafo/stats/core.py on lines 1253..1253
            src/wafo/stats/core.py on lines 1353..1353

            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 25 locations. Consider refactoring.
            Open

                    d, m = points.shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 24 other locations - About 30 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 187..187
            src/wafo/gaussian.py on lines 335..335
            src/wafo/gaussian.py on lines 717..717
            src/wafo/graphutil.py on lines 238..238
            src/wafo/kdetools/gridding.py on lines 230..230
            src/wafo/kdetools/gridding.py on lines 341..341
            src/wafo/kdetools/kdetools.py on lines 709..709
            src/wafo/kdetools/kdetools.py on lines 759..759
            src/wafo/kdetools/kdetools.py on lines 773..773
            src/wafo/kdetools/kdetools.py on lines 805..805
            src/wafo/kdetools/kernels.py on lines 755..755
            src/wafo/kdetools/kernels.py on lines 799..799
            src/wafo/kdetools/kernels.py on lines 885..885
            src/wafo/kdetools/kernels.py on lines 999..999
            src/wafo/kdetools/kernels.py on lines 1103..1103
            src/wafo/kdetools/kernels.py on lines 1230..1230
            src/wafo/misc.py on lines 1188..1188
            src/wafo/misc.py on lines 2885..2885
            src/wafo/spectrum/core.py on lines 4114..4114
            src/wafo/stats/core.py on lines 951..951
            src/wafo/stats/core.py on lines 952..952
            src/wafo/stats/core.py on lines 953..953
            src/wafo/stats/core.py on lines 1253..1253
            src/wafo/stats/core.py on lines 1353..1353

            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 25 locations. Consider refactoring.
            Open

                    d, inc = X.shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 24 other locations - About 30 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 187..187
            src/wafo/gaussian.py on lines 335..335
            src/wafo/gaussian.py on lines 717..717
            src/wafo/graphutil.py on lines 238..238
            src/wafo/kdetools/gridding.py on lines 230..230
            src/wafo/kdetools/gridding.py on lines 341..341
            src/wafo/kdetools/kdetools.py on lines 226..226
            src/wafo/kdetools/kdetools.py on lines 759..759
            src/wafo/kdetools/kdetools.py on lines 773..773
            src/wafo/kdetools/kdetools.py on lines 805..805
            src/wafo/kdetools/kernels.py on lines 755..755
            src/wafo/kdetools/kernels.py on lines 799..799
            src/wafo/kdetools/kernels.py on lines 885..885
            src/wafo/kdetools/kernels.py on lines 999..999
            src/wafo/kdetools/kernels.py on lines 1103..1103
            src/wafo/kdetools/kernels.py on lines 1230..1230
            src/wafo/misc.py on lines 1188..1188
            src/wafo/misc.py on lines 2885..2885
            src/wafo/spectrum/core.py on lines 4114..4114
            src/wafo/stats/core.py on lines 951..951
            src/wafo/stats/core.py on lines 952..952
            src/wafo/stats/core.py on lines 953..953
            src/wafo/stats/core.py on lines 1253..1253
            src/wafo/stats/core.py on lines 1353..1353

            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 25 locations. Consider refactoring.
            Open

                    d, m = points.shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 24 other locations - About 30 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 187..187
            src/wafo/gaussian.py on lines 335..335
            src/wafo/gaussian.py on lines 717..717
            src/wafo/graphutil.py on lines 238..238
            src/wafo/kdetools/gridding.py on lines 230..230
            src/wafo/kdetools/gridding.py on lines 341..341
            src/wafo/kdetools/kdetools.py on lines 226..226
            src/wafo/kdetools/kdetools.py on lines 709..709
            src/wafo/kdetools/kdetools.py on lines 759..759
            src/wafo/kdetools/kdetools.py on lines 773..773
            src/wafo/kdetools/kernels.py on lines 755..755
            src/wafo/kdetools/kernels.py on lines 799..799
            src/wafo/kdetools/kernels.py on lines 885..885
            src/wafo/kdetools/kernels.py on lines 999..999
            src/wafo/kdetools/kernels.py on lines 1103..1103
            src/wafo/kdetools/kernels.py on lines 1230..1230
            src/wafo/misc.py on lines 1188..1188
            src/wafo/misc.py on lines 2885..2885
            src/wafo/spectrum/core.py on lines 4114..4114
            src/wafo/stats/core.py on lines 951..951
            src/wafo/stats/core.py on lines 952..952
            src/wafo/stats/core.py on lines 953..953
            src/wafo/stats/core.py on lines 1253..1253
            src/wafo/stats/core.py on lines 1353..1353

            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 25 locations. Consider refactoring.
            Open

                    d, m = points.shape
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 24 other locations - About 30 mins to fix
            src/wafo/doc/tutorial_scripts/chapter5.py on lines 187..187
            src/wafo/gaussian.py on lines 335..335
            src/wafo/gaussian.py on lines 717..717
            src/wafo/graphutil.py on lines 238..238
            src/wafo/kdetools/gridding.py on lines 230..230
            src/wafo/kdetools/gridding.py on lines 341..341
            src/wafo/kdetools/kdetools.py on lines 226..226
            src/wafo/kdetools/kdetools.py on lines 709..709
            src/wafo/kdetools/kdetools.py on lines 759..759
            src/wafo/kdetools/kdetools.py on lines 805..805
            src/wafo/kdetools/kernels.py on lines 755..755
            src/wafo/kdetools/kernels.py on lines 799..799
            src/wafo/kdetools/kernels.py on lines 885..885
            src/wafo/kdetools/kernels.py on lines 999..999
            src/wafo/kdetools/kernels.py on lines 1103..1103
            src/wafo/kdetools/kernels.py on lines 1230..1230
            src/wafo/misc.py on lines 1188..1188
            src/wafo/misc.py on lines 2885..2885
            src/wafo/spectrum/core.py on lines 4114..4114
            src/wafo/stats/core.py on lines 951..951
            src/wafo/stats/core.py on lines 952..952
            src/wafo/stats/core.py on lines 953..953
            src/wafo/stats/core.py on lines 1253..1253
            src/wafo/stats/core.py on lines 1353..1353

            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 4 locations. Consider refactoring.
            Open

                def _check_xmax(self, xmax):
        return xmax
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 30 mins to fix
            src/wafo/kdetools/kdetools.py on lines 113..114
            src/wafo/stats/_continuous_distns.py on lines 7616..7617
            src/wafo/stats/_continuous_distns.py on lines 7619..7620

            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 4 locations. Consider refactoring.
            Open

                def _check_xmin(self, xmin):
        return xmin
            Severity: Major
            Found in src/wafo/kdetools/kdetools.py and 3 other locations - About 30 mins to fix
            src/wafo/kdetools/kdetools.py on lines 127..128
            src/wafo/stats/_continuous_distns.py on lines 7616..7617
            src/wafo/stats/_continuous_distns.py on lines 7619..7620

            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

                                     plot_kwds=dict(markersize=6, color=color, picker=5))
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 30 mins to fix
            src/wafo/spectrum/core.py on lines 3835..3835

            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

                        _assert(d == 1 and m == self.d, "points have dimension {}, "
                    "dataset has dimension {}".format(d, self.d))
            Severity: Minor
            Found in src/wafo/kdetools/kdetools.py and 1 other location - About 30 mins to fix
            src/wafo/stats/estimation.py on lines 598..598

            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