This gem allow to calculate descriptive and inference statistic in many different scenarios.
It use the Gsl library through https://github.com/SciRuby/rb-gsl
to make the calculation faster.
Summary statistics that quantitatively describe or summarize features of a collection of information.
Get the mean
, variance
, standard_deviation
, max
, min
, skew
, kurtosis
, median
, mode
, etc from a dataset.
- Simple numbers arrays
- Lower-Upper boundary arrays (rage/grouped data)
Get the mean
, variance
, standard_deviation
, median
, skewness
, kurtosis
, coefficient_variation
, cumulative_less_than_x_probability
, cumulative_greater_than_x_probability
, etc from statistics distributions.
Properties of observable (either finite or countably infinite) pre-defined values.
- beta
- chi_square
- exponential
- fisher_snedecor
- gamma
- gumbel_maximum
- gumbel_minimum
- log_normal
- normal
- pareto
- t_student
- weibull
Properties of infinite number of outcomes.
- binomial
- geometric
- hypergeometric
- hyperpascal
- pascal
- poisson
Process of deducing properties of an underlying probability distribution by analysis of data. Inferential statistical analysis infers properties about a unknowns population.
- Mean Known Sigma
P(A < mu < B) = 1 - alpha
- Mean Unknown Sigma
P(A < mu < B) = 1 - alpha
- Variance
P(A < sigma^2 < B) = 1 - alpha
- Standard deviation
P(A < sigma < B) = 1 - alpha
- P Bernoulli process
P(A < p < B) = 1 - alpha
Test Type 1
, Type 2
or Type 3
hypotheses over
- Mean Known Sigma
- Mean Unknown Sigma
- Variance
- Standard deviation
- P Bernoulli process
Compare 2 parameters to determine if one os greater than other
- Mean Known Sigma
- Mean Unknown Sigma
- Mean Independent population
- Variance
- Standard deviation
- Independence
- Chi-square contrast
- Goodness of fit
- Simple linear
- Multiple linear
Note that the GSL libraries must already be installed before Ruby/GSL can be installed:
- Debian/Ubuntu:
sudo apt-get install libgsl2 libgsl0-dev
- Fedora/SuSE: +gsl-devel+
- Gentoo: +sci-libs/gsl+
- OS X:
brew install gsl
Add this line to your application's Gemfile:
gem 'statistic_calcs'
And then execute:
`$ bundle`
Or install it yourself as:
`$ gem install statistic_calcs`
# calc to get f(x) & g(x), knowing x
options = { mean: 0, standard_deviation: 1, x: 1.64489 }
dist = StatisticCalcs::Distributions::Normal.new(options)
dist.calc!
dist.to_h # {:mean=>0, :standard_deviation=>1, :x=>1.64489, :cumulative_less_than_x_probability=>0.95, :cumulative_greater_than_x_probability=>0.05, :variance=>1}
# calc to get f(x) & g(x), knowing f_x
options = { mean: 0, standard_deviation: 1, f_x: 0.92507 }
# calc to get f(x) & g(x), knowing g_x
options = { mean: 0, standard_deviation: 1, g_x: 0.07493 }
Example:
ChiSquare
attr_accessor :degrees_of_freedom
attr_alias :v, :degrees_of_freedom
attr_alias :nu, :degrees_of_freedom
# Simple number array
array = [-5, 1.2, 2.3, 3.4]
calc = StatisticCalcs::DataSets::DataSet.new(x_values: array)
calc.calc! # @kurtosis=-1.76886, @max=3.4, @mean=0.475, @median=1.75, @min=-5.0, @skew=-0.62433, @standard_deviation=3.758878378807522, @variance=14.12917
# with lower-upper boundary values
x_values = [1.2, 2.3, 3.4, 1]
lower_class_boundary_values = [1.2, 4.3, 9.4, 14.5]
upper_class_boundary_values = [4.3, 9.4, 14.5, 19.6]
calc = StatisticCalcs::GroupedDataSet.new(
x_values: x_values,
lower_class_boundary_values: lower_class_boundary_values,
upper_class_boundary_values: upper_class_boundary_values
)
calc.calc!
Also to generate the histogram
list = [738, 600, 920, 1000, 897, 999, 601, 602]
calc = StatisticCalcs::DataSets::DataSet.new(x_values: list)
calc.split_in(4) # or group_each(100)
calc.intervals # => 4
calc.range # => 100
calc.histogram_keys # => ['less_than_700.0', '700.0..800.0', '800.0..900.0', '900.0_or_more_than']
calc.adjusted_keys # => ['600..700.0', '700.0..800.0', '800.0..900.0', '900.0..1000']
calc.histogram_values # => [3, 1, 1, 3]
calc.grouped_values # => [[600, 601, 602], [738], [897], [920, 1000, 999]]
calc.grouped_values_hash # => {'less_than_700.0'=>[600, 601, 602], '700.0..800.0'=>[738], '800.0..900.0'=>[897], '900.0_or_more_than'=>[920, 1000, 999]}
To calculate the population lower and upper limits, knowing sigma.
options = { alpha: 0.1, standard_deviation: 15.0, sample_size: 10, sample_mean: 246.0 }
calculator = StatisticCalcs::Inference::KnownSigmaMean.new(options)
calculator.calc!
# @deviation_amount=1.64485 (z-normal), @population_mean_lower_limit=238.19779138600805, @population_mean_upper_limit=253.80220861399195, @population_standard_deviation=15.0, @sample_error=8
To calculate the sample size.
options = { alpha: 0.1, standard_deviation: 15.0, sample_mean: 246.0, sample_error: 5 }
calculator = StatisticCalcs::Inference::KnownSigmaMean.new(options)
calculator.calc!
# @sample_size=25
population_size: 900
To calculate the population lower and upper limits, if you doesn't know sigma you should use the sample standard deviation:
options = { alpha: 0.05, sample_standard_deviation: 1.7935, sample_size: 4, sample_mean: 17.35 }
calculator = StatisticCalcs::Inference::UnknownSigmaMean.new(options)
calculator.calc!
calculator.to_h # @deviation_amount=3.18245 (t student), @population_mean_lower_limit=14.4961..., @population_mean_upper_limit=20.2038..., @sample_error=3
Will use the sample variance to estimate the population variance with a error: So the pop variance will be X +/- error -> will be between lower_limit < x < upper_limit
options = { alpha: 0.1, sample_variance: 14_400, sample_size: 15 }
calculator = StatisticCalcs::Inference::Variance.new(options)
calculator.calc!
calculator.to_h
# { :degrees_of_freedom=>14, :population_variance_lower_limit=>8511.791744828643, :population_variance_upper_limit=>30681.989398276877, :sample_error=>11085.098826724117, :limits_relationship_variance=>3.6046452166687213}
To estimate how to improve an error, and get how much samples you will need, it use the relationship between lower and upper, so the R = B /A -> improving the R will improve the error
options = { alpha: 0.1, sample_variance: 14_400, limits_relationship_variance: 4 }
calculator = StatisticCalcs::Inference::Variance.new(options)
calculator.calc!
calculator.to_h
# { :sample_size=>14, :degrees_of_freedom=>13 }
Same as variance, can be used to estimate the standard deviation of the total population
options = { alpha: 0.1, sample_standard_deviation: 120, sample_size: 15 }
calculator = StatisticCalcs::Inference::StandardDeviation.new(options)
calculator.calc!
calculator.to_h
# { degrees_of_freedom=>14, :limits_relationship_standard_deviation=>1.8985903235476371, :population_standard_deviation_lower_limit=>92.25937212461747, :population_standard_deviation_upper_limit=>175.16275117237933, :sample_error=>41.45168952388093 }
Same as variance, to improve the error
options = { alpha: 0.1, sample_standard_deviation: 14_400, limits_relationship_variance: 4 }
calculator = StatisticCalcs::Inference::StandardDeviation.new(options)
calculator.calc!
calculator.to_h
# { :sample_size=>14, :degrees_of_freedom=>13 }
In a Bernoulli process, if the sampling is made to the Binomial
the size of the sample n
is fixed and the number of successes obtained r
is observed in the sample.
Therefore, the estimator p
is a random variable of Binomial behavior
corresponding to the probability of success of the Process a Bernoulli Process.
Sample p'= r /n and population is P(A < p < B) = 1 - alpha.
options = { alpha: 0.1, n: 30, r: 3 }
calculator = StatisticCalcs::Inference::PBernoulliProcess.new(options)
calculator.calc!
calculator.to_h
# { :confidence_level=>0.9, :sample_probability_of_success=>0.1, :probability_of_success_lower_limit=>0.02782, :probability_of_success_upper_limit=>0.2386, :sample_error=>0.10539 }
Define and test an Hypotheses on statistic variables. Define the null hypotheses as unquestionable, you try to prove that it is false.
h0 = null hypothesis
h1 = alternative hypothesis
confidence_level = Prob(no reject true h0). Correct decision
alpha = Prob(reject true h0). Type 1 error. worst error
test_power = Prob(reject false h0). Type 2 less serious error
beta = Prob(no reject false h0). Correct decision
Use the different cases depending the problem
CASE_1 = unilateral right
CASE_2 = unilateral left
CASE_3 = bilateral
Test a sample mean, knowing or not the population standard deviation
Calculated using the Normal distribution
options = {
alpha: 0.05,
standard_deviation: 15.0,
sample_size: 10,
sample_mean: 230.0,
mean_to_test: 250,
case: StatisticCalcs::HypothesisTest::Cases::CASE_1
}
calculator = StatisticCalcs::HypothesisTest::KnownSigmaMean.new(options)
calculator.calc!
calculator.to_h
# {
# null_hypothesis: "mean <= x0 (250)",
# alternative_hypothesis: "mean > x1 ()",
# critical_fractil: 257.8022086139919,
# reject: false,
# reject_condition: "X > Xc -> reject H0. `230.0 > 257.8` -> false"
# }
Calculated using the TStudent distribution
options = {
alpha: 0.05,
standard_deviation: 15.0,
sample_size: 10,
sample_mean: 230.0,
mean_to_test: 250,
case: StatisticCalcs::HypothesisTest::Cases::CASE_1
}
calculator = StatisticCalcs::HypothesisTest::KnownSigmaMean.new(options)
calculator.calc!
calculator.to_h
# {
# null_hypothesis: "mean <= x0 (250)",
# alternative_hypothesis: "mean > x1 ()",
# critical_fractil: 258.69520420244686,
# reject: false,
# reject_condition: "X > Xc -> reject H0. `230.0 > 258.7` -> false"
# }
options = {
sample_size: 30,
alpha: 0.05,
sample_variance: 225,
variance_to_test: 400,
case: StatisticCalcs::HypothesisTest::Cases::CASE_1
}
calculator = StatisticCalcs::HypothesisTest::Variance.new(options)
calculator.calc!
calculator.to_h
# {
# null_hypothesis: 'sigma^2 <= s0 (400)',
# alternative_hypothesis: 'sigma^2 > s1 ()',
# critical_fractil: 586.9926896551724,
# reject: false,
# reject_condition: 'S^2 > S^2c -> reject H0. `225 > 586.99` -> false',
# }
options = {
sample_size: 30,
alpha: 0.05,
sample_standard_deviation: 15,
standard_deviation_to_test: 20,
case: StatisticCalcs::HypothesisTest::Cases::CASE_1
}
calculator = StatisticCalcs::HypothesisTest::StandardDeviation.new(options)
calculator.calc!
calculator.to_h
# {
# null_hypothesis: 'sigma <= s0 (20)',
# alternative_hypothesis: 'sigma > s1 ()',
# critical_fractil: 24.227932013590685,
# reject: false,
# reject_condition: 'S > Sc -> reject H0. `15 > 24.23` -> false'
# }
TODO: to be implemented - priority 3
- variance
- standard_deviation
- mean
Let's say that we have a list of data, and we want to view if those values adjust to a statistic model. We need at least 60 values. We group in N categories (clusters)
For instance to an uniform
- Uniform
- Normal
- Log Normal
- Gumbel Maximum
- Gumbel Minimum
- TODO: Binomial
- TODO: Poisson
- TODO: Pareto
values = [
600, 1000, 985, 998, 692, 973, 631, 814, 739, 733, 838, 813, 731, 801, 913, 754, 778, 697, 646,
649, 759, 909, 671, 801, 995, 677, 719, 960, 713, 881, 900, 981, 608, 909, 998, 877, 785, 681,
897, 679, 965, 948, 684, 766, 989, 878, 807, 672, 741, 670, 752, 818, 766, 759, 866, 650, 941, 819, 756, 635
]
options = { data_set: values, clusters_count: 4 }
calculator = StatisticCalcs::ChiSquareContrast::UniformGoodnessAndFit.new(options)
calculator.calc!
calculator.cluster_keys # ["less_than_700.0", "700.0..800.0", "800.0..900.0", "900.0_or_more_than"])
calculator.cluster_values # ["600..700.0", "700.0..800.0", "800.0..900.0", "900.0..1000"])
calculator.cluster_mid_points # [650.0, 750.0, 850.0, 950.0]
calculator.observed_frequencies # [16, 15, 13, 16]
# model probability
calculator.occurrence_probabilities # [0.25, 0.25, 0.25, 0.25]
# frequency if model apply
calculator.expected_frequencies # [15, 15, 15, 15]
calculator.critical_chi_square # 0.4
# So with this calculated information we can test if it match or not with the hypotheses test
test_calc = StatisticCalcs::HypothesisTest::GoodnessAndFit.new(data: calculator)
test_calc.calc!
test_calc.null_hypothesis # 'Xc^2 <= X^2(1 - alpha, V). 0.4 <= 30.14353'
test_calc.alternative_hypothesis # 'Xc^2 > X^2'
test_calc.critical_fractil # 0.4
test_calc.reject # true
test_calc.reject_condition # 'Xc^2 > X^2 -> reject H0. `0.4 > 30.14` -> true'
# model doesn't fit to uniform dist
lower_class_boundary_values = [0, 15, 30, 45, 60, 75, 105]
upper_class_boundary_values = [15, 30, 45, 60, 75, 105, 200]
observed_frequencies = [8, 20, 25, 35, 25, 18, 0]
options = {
lower_class_boundary_values: lower_class_boundary_values,
upper_class_boundary_values: upper_class_boundary_values,
observed_frequencies: observed_frequencies
}
calculator = StatisticCalcs::ChiSquareContrast::GumbelMinimumGoodnessAndFit.new(options)
calculator.calc!
calculator.cluster_mid_points).to eq([7.5, 22.5, 37.5, 52.5, 67.5, 90.0, 152.5])
calculator.occurrence_probabilities).to eq([0.6133, 0.09030, 0.0855200, 0.07447999, 0.05830, 0.062759, 0.01534])
calculator.expected_frequencies).to eq([80.3423, 11.829300, 11.20312, 9.756879, 7.63730, 8.221559, 2.00954])
calculator.critical_chi_square).to eq(206.1952)
# So with this calculated information we can test if it match or not with the hypotheses test
test_calc = StatisticCalcs::HypothesisTest::GoodnessAndFit.new(data: calculator)
test_calc.calc!
test_calc.null_hypothesis # 'Xc^2 <= X^2(1 - alpha, V). 206.1952 <= 9.48773'
test_calc.alternative_hypothesis # 'Xc^2 > X^2'
test_calc.critical_fractil # 206.1952
test_calc.reject_condition # true
test_calc.reject # 'Xc^2 > X^2 -> reject H0. `206.2 > 9.49` -> true'
# model doesn't fit to uniform dist
Estimation of a variable (the dependent variable) from another variables (the independent variables).
This class will calculate the related correlation or degree of relationship between the variables,
in which will try to determine how well a linear equation, describes or explains the relationship between them
Model: Y = Beta0 + Beta1 X + E
Estimator: y = b0 + b1 x
Y: variable to explain
X: explains variable, known value (constant)
Beta0: intercept
Beta1: slope
E: disturbance of the environment, error, noise
x_values = [3.0402, 2.9819, 3.0934, 3.805, 5.423]
y_values = [8.014, 7.891, 8.207, 8.31, 8.45]
options = { x_values: x_values, y_values: y_values }
calculator = StatisticCalcs::Regression::SimpleLinearRegression.new(options)
calculator.calc!
calculator.to_h
# {
# b1: 0.18134495612017704, # slope
# b0: 7.509099759481907, # intercept
# n: 5,
# degrees_of_freedom: 3,
# r: 0.8372299658466078, # correlation_coefficient_estimator
# r_square: 0.7009540157115121, # determination_coefficient_estimator
# r_square_adj: 0.7009540157115121, determination_coefficient_adjusted_estimator
# covariance: 0.15573262000000554
# x_values_variance: 1.07346
# x_values_standard_deviation: 1.0360770675968076
# equation: y = 7.509 + 0.181 x
# ro_boundaries= 'P(-0.172 < ro < 0.989) = 95.0%'
# ro_lower_limit= -0.17232618950437983
# ro_upper_limit= 0.9889779447869926
# ro_square_boundaries= 'P(0.03 < ro < 0.978) = 95.0%'
# ro_square_lower_limit= 0.02969631558909943
# ro_square_upper_limit= 0.9780773752751039
# valid_correlation_for_social_problems: true # > 0.6
# valid_correlation_for_economic_problems: true # > 0.7
# valid_correlation_for_tech_problems: false # > 0.8
# b1_standard_deviation = 0.06838629521911997
# model_standard_deviation = 0.14170694442887077
# model_variance = 0.02008085809936707
# }
# And get a value
result = subject.y0_estimation(5.401)
result[:y0] # 8.488543867486984
result[:lower_limit] # 8.060977652566306
result[:upper_limit] # 8.916110082407661
result[:y0_boundaries] # 'P(8.061 < y0 < 8.916) = 95.0%'
The most important thing that this gem make =)
Similar to simple linear regression, but can be used multiple variables to review if the independent variables affect (or not) to the dependant
Model: Y = Beta0 + Beta1 X1 + Beta2 X2 + ... + BetaN XN +E
Estimator: y = b0 + b1 x1 + b2 x2 + .. + bn xn
Y: variable to explain
X: explains variables, known values (constant) Is a N
x Variables count
Matrix
Usually is easy to add more variables to explain the dependent one, but if we add too much variables, and doesn´t add a significant amount, probably is better to exclude from the list. This analysis is too complex, and depends of many factors. Let´s jump into code first
x1_values [1, 2.5, 3.1, 4, 4.7, 5.3, 6, 7.1, 9] }
x2_values [9, 12, 13, 14, 14.5, 16, 17, 19, 19.6] }
x3_values [3, 4, 5, 2, 4, 8, 12, 10, 23.2] }
x_values [x1_values, x2_values, x3_values] }
y_values [5, 8.5, 10, 11.2, 14, 16, 16.8, 18.55, 20] }
options { x_values: x_values, y_values: y_values } }
calc = StatisticCalcs::Regression::MultipleLinearRegression.new(options)
# all the possible combinations
calc.possible_scenarios # [['x1'], ['x2'], ['x3'], ['x1' 'x2'], ['x1' 'x3'], ['x2' 'x3'], ['x1' 'x2' 'x3']]
calc.possible_scenarios_keys # ['x1' 'x2' 'x3' 'x1x2' 'x1x3' 'x2x3' 'x1x2x3']
analysis = calc.multicollinearity_analysis
# to check which one is better you should compare the following statistics
analysis[0] # {:name=>"x1", delta_sum=>10.680, :prediction_sum_square=> 21.281, :r_square=>0.955, :s_square=> 1.258, :det=>1, :p=>2, :c_p=> 5.231})
analysis[1] # {:name=>"x2", delta_sum=> 7.275, :prediction_sum_square=> 7.025, :r_square=>0.975, :s_square=> 0.699, :det=>1, :p=>2, :c_p=> 0.686})
analysis[2] # {:name=>"x3", delta_sum=>35.603, :prediction_sum_square=>205.417, :r_square=>0.606, :s_square=>11.224, :det=>1, :p=>2, :c_p=>86.251})
analysis[3] # {:name=>"x1x2", delta_sum=>11.134, :prediction_sum_square=> 27.189, :r_square=>0.976, :s_square=> 0.766, :det=>0.034, :p=>3, :c_p=> 2.341})
analysis[5] # {:name=>"x2x3", delta_sum=> 8.929, :prediction_sum_square=> 9.995, :r_square=>0.975, :s_square=> 0.815, :det=>0.382, :p=>3, :c_p=> 2.682})
analysis[4] # {:name=>"x1x3", delta_sum=>10.376, :prediction_sum_square=> 28.581, :r_square=>0.970, :s_square=> 0.988, :det=>0.261, :p=>3, :c_p=> 3.891})
analysis[6] # {:name=>"x1x2x3", delta_sum=>14.146, :prediction_sum_square=> 45.171, :r_square=>0.978, :s_square=> 0.861, :det=>0.005, :p=>4, :c_p=> 4})
# So first
# 1 - Parsimony Principle: The principle that the most acceptable explanation of an occurrence, phenomenon, or event is the simplest
# 2 - R² (which one is more related) the greatest possible. (to replace by adjusted)
# 3 - S² (which dispersion have each one) the lowest possible
# 4 - PRESS. Prediction square sum the lowest possible
# 5 - DET of correlation matrix should be at least 0.1 and closed to 1 is better
# 6 - Mallow´s cp: CP divided parameter count of each model (CP / p) should be less than 5.
# selecting one is subjective, for the example:
# first I remove `x3` because the r² is too slow. (the others are similar)
# second I remove `x1` & `x1x3` because the s² is to high
# third I remove the `x1x2` & `x1x2x3` because the PRESS is too high
# lastly I choose `x2` only because has similar values and less variables to analyse
# Also you can view
calc.correlation_matrix # Matrix[[1.0, 0.9776, 0.9876, 0.778], [0.977, 1.0, 0.982, 0.859], [0.987, 0.982, 1.0, 0.785], [0.778, 0.859, 0.785, 1.0]]
calc.r_square_matrix # Matrix[[1.0, 0.9558, 0.9754, 0.606], [0.955, 1.0, 0.965, 0.738], [0.975, 0.965, 1.0, 0.617], [0.606, 0.738, 0.617, 1.0]]
calc.adj_r_square_matrix # Matrix[[1.0, 0.9411, 0.9673, 0.475], [0.941, 1.0, 0.954, 0.651], [0.967, 0.954, 1.0, 0.489], [0.475, 0.651, 0.489, 1.0]]
Let's say a simple example with the following sample data
x1_values [1, 2, 3, 4, 5] }
x2_values [1, 3, 7, 9, 3] }
x_values [x1_values, x2_values] }
y_values [8, 9, 7, 5, 4] }
options { x_values: x_values, y_values: y_values } }
calc = StatisticCalcs::Regression::MultipleLinearRegression.new(options)
# excel result
# Groups Count Sum Mean Variance
# Column 1 5 33 6.6 4.3
# Column 2 5 15 3 2.5
# Column 3 23 4.6 10.8
calc.n # 5
calc.x_values_mean_matrix.to_a # [3.0, 4.6]
calc.y_values_mean # 6.6
calc.x_values_sum_matrix.to_a # [15.0, 23.0]
calc.y_values_sum # 33.0
calc.x_values_variance_matrix.to_a # [2.5, 10.8]
calc.y_values_variance # 4.3
# excel result: liniest formula `=LINIEST(A2:A6,B2:C6,1, 1)`
# 0.0361445783 -1.2361445783 10.1421686747 --> Slopes and intercept
# 0.203753428 0.4234935474 1.273744148 ----> Standard errors/deviations
# 0.8397310171 1.1740158657 #N/A -----------> R^2 coefficients, Stand error Y
# 5.2395104895 2 #N/A ---------------------> F observed, degrees of freedom
# 14.443373494 2.756626506 #N/A -------------> Sum squares, Residual sum squares
calc.b_values[:b2] # 0.03614 # slope b2
calc.b_values[:b1] # -1.23614 # slope b1
calc.b_values[:b0] # 10.14216 # intercept b0
calc.b_values_standard_errors[:b2] # 0.20375
calc.b_values_standard_errors[:b1] # 0.42349
calc.b_values_standard_errors[:b0] # 1.27374
calc.r_square # 0.83973
calc.y_standard_error # 1.17401
calc.f_observed # 5.23951
calc.degrees_of_freedom # 2
calc.sum_squares # 14.44337
calc.residual_sum_squares # 2.75662
calc.total_sum_squares # 17.2
calc.r # 0.91636
calc.covariance_matrix.to_a # [[3.44, -2.4, -2.16], [-2.4, 2.0, 2.0], [-2.16, 2.0, 8.64]]
calc.correlation_matrix.to_a # [[1.0, -0.91499, -0.39620], [-0.91499, 1.0, 0.48112], [-0.39620, 0.48112, 1.0]]
calc.r_square_matrix.to_a # [[1.0, 0.83720, 0.15697], [0.83720, 1.0, 0.23148], [0.15697, 0.23148, 1.0]]
calc.x_values_standard_deviation_matrix.to_a # [1.58113, 3.28633]
calc.r # 0.91636
calc.valid_correlation_for_social_problems? # true
calc.valid_correlation_for_economic_problems? # true
calc.valid_correlation_for_tech_problems? # true
calc.equation # 'y = 10.142 - 1.2361 x1 + 0.0361 x2'
After checking out the repo, run bin/setup
to install dependencies. Then, run rake spec
to run the tests. You can also run bin/console
for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run bundle exec rake install
. To release a new version, update the version number in version.rb
, and then run bundle exec rake release
, which will create a git tag for the version, push git commits and tags, and push the .gem
file to rubygems.org.
Bug reports and pull requests are welcome on GitHub at https://github.com/mberrueta/statistic_calcs
. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
The gem is available as open source under the terms of the MIT License.
Everyone interacting in the StatisticCalcs project’s codebase, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.