# SciRuby/statsample

### Showing 95 of 133 total issues

#### Method `correlation_matrix_pairwise` has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open

``````      def correlation_matrix_pairwise(ds)
cache={}
vectors = ds.vectors.to_a
cm = vectors.collect do |row|
vectors.collect do |col|``````
Found in lib/statsample/bivariate.rb - About 35 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `report_building` has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open

``````      def report_building(builder) # :nodoc:
builder.section(:name=>@name) do |s|
if summary_descriptives
s.table(:name=>_("Descriptives"),:header=>%w{Name N Mean SD Min Max}.map {|v| _(v)}) do |t|
@vectors.each do |v|``````
Found in lib/statsample/anova/oneway.rb - About 35 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `initialize` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````    def initialize(p1, min_max=false, opts=Hash.new)

if p1.is_a? Array
range=p1
@n_bins=p1.size-1``````
Found in lib/statsample/histogram.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `min_n_valid` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def min_n_valid(ds)
min = ds.nrows
m   = n_valid_matrix(ds)
for x in 0...m.row_size
for y in 0...m.column_size``````
Found in lib/statsample/bivariate.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `report_building` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````    def report_building(generator)
@name||= (_type==:correlation ? _("Correlation"):_("Covariance"))+_(" Matrix")
row_size.times {|i|
t.row([fields_x[i]]+row(i).to_a.collect {|i1|``````
Found in lib/statsample/matrix.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `psi` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def psi
if @psi.nil?
c(@c) if @c
c_by_index(@c1,@c2) if (@c1 and @c2)
end``````
Found in lib/statsample/anova/contrast.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `create_hash` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def create_hash(dataset, vectors, sep=Statsample::SPLIT_TOKEN)
raise ArgumentError,"Array should't be empty" if vectors.size==0
pro_hash = vectors.inject({}) do |h,v_name|
v_name = v_name.is_a?(Numeric) ? v_name : v_name.to_sym
raise Exception, "Vector #{v_name} doesn't exists on Dataset" if ``````
Found in lib/statsample/codification.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `initialize` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def initialize(ds,y_var, opts=Hash.new)
@ds    = ds
@y_var = y_var.respond_to?(:to_sym) ? y_var.to_sym : y_var
@n     = ds.nrows
``````
Found in lib/statsample/dominanceanalysis/bootstrap.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `report_building` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````    def report_building(generator)
iterate if @clean
generator.section(:name=>@name) do |s|
s.text _("Number of factors: %d") % m
s.text _("Iterations: %d") % @iterations``````
Found in lib/statsample/factor/principalaxis.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `ssr_direct` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````        def ssr_direct
mean=@dy.mean
cases=0
ssr=(0...@ds.cases).inject(0) {|a,i|
invalid=false``````
Found in lib/statsample/regression/multiple/baseengine.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `multiple` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def self.multiple(ds,y_var, opts=Hash.new)
missing_data= (opts[:missing_data].nil? ) ? :listwise : opts.delete(:missing_data)
if missing_data==:pairwise
Statsample::Regression::Multiple::RubyEngine.new(ds,y_var, opts)
else``````
Found in lib/statsample/regression.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `predicted` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````        def predicted
Daru::Vector.new(
@total_cases.times.collect do |i|
invalid = false
vect = @dep_columns.collect {|v| invalid = true if v[i].nil?; v[i]}``````
Found in lib/statsample/regression/multiple/baseengine.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `initialize` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````      def initialize(opts=Hash.new, &block)
@scales=Hash.new
@scales_keys=Array.new
opts_default={  :name=>_("Multiple Scale analysis"),
:summary_correlation_matrix=>false,``````
Found in lib/statsample/reliability/multiscaleanalysis.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `create_has_library` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````  def self.create_has_library(library)
define_singleton_method("has_#{library}?") do
cv = "@@#{library}"
unless class_variable_defined? cv
begin``````
Found in lib/statsample.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

#### Method `union` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````    def union(&block)
union_field={}
types={}
names={}
labels={}``````
Found in lib/statsample/multiset.rb - About 25 mins to fix

# Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

### A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"