diff --git a/src/DotsMF.jl b/src/DotsMF.jl
index 25a2632..4f9e0b9 100644
--- a/src/DotsMF.jl
+++ b/src/DotsMF.jl
@@ -2,7 +2,7 @@ get_dots(membership_function::MF, input_point_vector::Union{StepRange,StepRangeL
     get_dots(membership_function, collect(input_point_vector))
 
 function get_dots(membership_function::MF, input_point_vector::Vector{T}) where {T<:Number}
-    return Real.(map(x -> Fuzzy.eval(membership_function, x), input_point_vector))
+    return Real.(map(x -> Fuzzy.evaluate(membership_function, x), input_point_vector))
 end
 
 chart_prepare(sets_dict::Dict{String,N}, input_point_vector::Union{StepRange,StepRangeLen}) where {N<:MF} =
diff --git a/src/Eval.jl b/src/Eval.jl
index 6053649..8b2340a 100644
--- a/src/Eval.jl
+++ b/src/Eval.jl
@@ -19,7 +19,7 @@ function eval_fis(fis::FISMamdani, input_values::Vector{<:AbstractFloat}, defuzz
         tmp_strengths = AbstractFloat[]
         for i in 1:length(rule.input_mf_names)
             if (rule.input_mf_names[i] !== "")
-                push!(tmp_strengths, eval(fis.input_mfs_dicts[i][rule.input_mf_names[i]], input_values[i]))
+                push!(tmp_strengths, evaluate(fis.input_mfs_dicts[i][rule.input_mf_names[i]], input_values[i]))
             end
         end
         push!(firing_strengths, firing(tmp_strengths, rule.firing_method))
@@ -46,7 +46,7 @@ function eval_fis(fis::FISSugeno, input_values::Vector{<:AbstractFloat})
         tmp_strengths = AbstractFloat[]
         for i in 1:length(rule.input_mf_names)
             if (rule.input_mf_names[i] !== "")
-                push!(tmp_strengths, eval(fis.input_mfs_dicts[i][rule.input_mf_names[i]], input_values[i]))
+                push!(tmp_strengths, evaluate(fis.input_mfs_dicts[i][rule.input_mf_names[i]], input_values[i]))
             end
         end
         push!(firing_strengths, firing(tmp_strengths, rule.firing_method))
@@ -90,7 +90,7 @@ function defuzz(firing_strengths::Vector{AbstractFloat}, rules::Vector{Rule},	ou
             push!(mean_vec, mean_at(output_mfs_dict[rules[i].output_mf], firing_strengths[i]))
         end
         sumfire = sum(firing_strengths)
-        if sumfire != 0               
+        if sumfire != 0
             (mean_vec' * firing_strengths)[1] / sum(firing_strengths)
         else
             mean_vec
diff --git a/src/EvalMF.jl b/src/EvalMF.jl
index 8216e61..1b9a42d 100644
--- a/src/EvalMF.jl
+++ b/src/EvalMF.jl
@@ -1,4 +1,4 @@
-function eval(membership_function::TriangularMF, x::T) where {T <: Number}
+function evaluate(membership_function::TriangularMF, x::T) where {T <: Number}
     return maximum([minimum([((x - membership_function.l_vertex) / (membership_function.center - membership_function.l_vertex)), ((membership_function.r_vertex - x) / (membership_function.r_vertex - membership_function.center))]), 0])
 end
 
@@ -12,8 +12,8 @@ function mean_at(membership_function::TriangularMF, firing_strength::T) where {T
     end
 end
 
-function eval(menbership_function::GaussianMF, x::T) where {T <: Number}
-    return exp(- 0.5 * ((x - menbership_function.center) / menbership_function.sigma)^2)    
+function evaluate(menbership_function::GaussianMF, x::T) where {T <: Number}
+    return exp(- 0.5 * ((x - menbership_function.center) / menbership_function.sigma)^2)
 end
 
 function mean_at(membership_function::GaussianMF, firing_strength::T) where {T <: Number}
@@ -21,7 +21,7 @@ function mean_at(membership_function::GaussianMF, firing_strength::T) where {T <
 end
 
 
-function eval(membership_function::BellMF, x::T) where {T <: Number}
+function evaluate(membership_function::BellMF, x::T) where {T <: Number}
     return (1 / (1 + abs((x - membership_function.c) / membership_function.a)^(2 * membership_function.b)))
 end
 
@@ -29,7 +29,7 @@ function mean_at(membership_function::BellMF, firing_strength::T) where {T <: Nu
     return membership_function.c
 end
 
-function eval(membership_function::TrapezoidalMF, x::T) where {T <: Number}
+function evaluate(membership_function::TrapezoidalMF, x::T) where {T <: Number}
     return  maximum([minimum([((x - membership_function.l_bottom_vertex) / (membership_function.l_top_vertex - membership_function.l_bottom_vertex)), 1, ((membership_function.r_bottom_vertex - x) / (membership_function.r_bottom_vertex - membership_function.r_top_vertex))]), 0])
 end
 
@@ -40,7 +40,7 @@ function mean_at(membership_function::TrapezoidalMF, firing_strength::T) where {
 end
 
 
-function eval(membership_function::SigmoidMF, x::T) where {T <: Number}
+function evaluate(membership_function::SigmoidMF, x::T) where {T <: Number}
     return  1 / (1 + exp(-membership_function.a * (x - membership_function.c)))
 end
 
@@ -56,4 +56,4 @@ function mean_at(membership_function::SigmoidMF, firing_strength::T) where {T <:
     p1 = -log((1 / p_firing_strength) - 1) / membership_function.a + membership_function.c
     p2 = membership_function.limit
     (p1 + p2) / 2
-end
\ No newline at end of file
+end
diff --git a/test/bell_mf.jl b/test/bell_mf.jl
index e8880b6..8df6d1d 100644
--- a/test/bell_mf.jl
+++ b/test/bell_mf.jl
@@ -5,8 +5,8 @@ c = 5
 mf = BellMF(a, b, c)
 
 # Evaluation tests
-@assert Fuzzy.eval(mf, c) == 1
-@assert Fuzzy.eval(mf, c - a) == Fuzzy.eval(mf, c + a) == 0.5
+@assert Fuzzy.evaluate(mf, c) == 1
+@assert Fuzzy.evaluate(mf, c - a) == Fuzzy.evaluate(mf, c + a) == 0.5
 
 # Mean finding tests
-@assert Fuzzy.mean_at(mf, 1) == Fuzzy.mean_at(mf, 0.6) == Fuzzy.mean_at(mf, 0.3) == Fuzzy.mean_at(mf, 0) == c
\ No newline at end of file
+@assert Fuzzy.mean_at(mf, 1) == Fuzzy.mean_at(mf, 0.6) == Fuzzy.mean_at(mf, 0.3) == Fuzzy.mean_at(mf, 0) == c
diff --git a/test/gaussian_mf.jl b/test/gaussian_mf.jl
index c8a90df..fb4807f 100644
--- a/test/gaussian_mf.jl
+++ b/test/gaussian_mf.jl
@@ -4,9 +4,9 @@ sigma = 2
 mf = GaussianMF(center, sigma)
 
 # Evaluation tests
-@assert Fuzzy.eval(mf, center + sigma) == exp(-0.5)
-@assert Fuzzy.eval(mf, center) == 1
-@assert Fuzzy.eval(mf, center + sigma) == Fuzzy.eval(mf, center - sigma)
+@assert Fuzzy.evaluate(mf, center + sigma) == exp(-0.5)
+@assert Fuzzy.evaluate(mf, center) == 1
+@assert Fuzzy.evaluate(mf, center + sigma) == Fuzzy.evaluate(mf, center - sigma)
 
 # Mean finding tests
 @assert Fuzzy.mean_at(mf, 1) == Fuzzy.mean_at(mf, 0.6) == Fuzzy.mean_at(mf, 0.3) == Fuzzy.mean_at(mf, 0) == center
diff --git a/test/sigmoid_mf.jl b/test/sigmoid_mf.jl
index c675b1e..e9fbdf8 100644
--- a/test/sigmoid_mf.jl
+++ b/test/sigmoid_mf.jl
@@ -5,8 +5,8 @@ limit = 10
 mf = SigmoidMF(a, c, limit)
 
 # Evaluation tests
-@assert Fuzzy.eval(mf, c) == 0.5
-@assert Fuzzy.eval(mf, c - 5) < Fuzzy.eval(mf, c + 5)
+@assert Fuzzy.evaluate(mf, c) == 0.5
+@assert Fuzzy.evaluate(mf, c - 5) < Fuzzy.evaluate(mf, c + 5)
 
 # Mean finding tests
-@assert Fuzzy.mean_at(mf, 1) > Fuzzy.mean_at(mf, 0.6) > Fuzzy.mean_at(mf, 0.3) > Fuzzy.mean_at(mf, 0)
\ No newline at end of file
+@assert Fuzzy.mean_at(mf, 1) > Fuzzy.mean_at(mf, 0.6) > Fuzzy.mean_at(mf, 0.3) > Fuzzy.mean_at(mf, 0)
diff --git a/test/trapezoidal_mf.jl b/test/trapezoidal_mf.jl
index a02c4b9..66982c2 100644
--- a/test/trapezoidal_mf.jl
+++ b/test/trapezoidal_mf.jl
@@ -6,10 +6,10 @@ r_bottom_vertex = 11
 mf = TrapezoidalMF(l_bottom_vertex, l_top_vertex, r_top_vertex, r_bottom_vertex)
 
 # Evaluation tests
-@assert Fuzzy.eval(mf, l_top_vertex) == Fuzzy.eval(mf, r_top_vertex) == 1
-@assert Fuzzy.eval(mf, l_bottom_vertex) == Fuzzy.eval(mf, r_bottom_vertex) == 0
-@assert Fuzzy.eval(mf, (l_bottom_vertex + l_top_vertex) / 2) == Fuzzy.eval(mf, (r_top_vertex + r_bottom_vertex) / 2) == 0.5
+@assert Fuzzy.evaluate(mf, l_top_vertex) == Fuzzy.evaluate(mf, r_top_vertex) == 1
+@assert Fuzzy.evaluate(mf, l_bottom_vertex) == Fuzzy.evaluate(mf, r_bottom_vertex) == 0
+@assert Fuzzy.evaluate(mf, (l_bottom_vertex + l_top_vertex) / 2) == Fuzzy.evaluate(mf, (r_top_vertex + r_bottom_vertex) / 2) == 0.5
 
 # Mean finding tests
 @assert Fuzzy.mean_at(mf, 1) == (l_top_vertex + r_top_vertex) / 2
-@assert Fuzzy.mean_at(mf, 0) == (l_bottom_vertex + r_bottom_vertex) / 2
\ No newline at end of file
+@assert Fuzzy.mean_at(mf, 0) == (l_bottom_vertex + r_bottom_vertex) / 2
diff --git a/test/triangular_mf.jl b/test/triangular_mf.jl
index 6edca18..0391749 100644
--- a/test/triangular_mf.jl
+++ b/test/triangular_mf.jl
@@ -5,10 +5,10 @@ r_vertex = 7.0
 mf = TriangularMF(l_vertex, center, r_vertex)
 
 # Evaluation tests
-@assert Fuzzy.eval(mf, center) == 1
-@assert Fuzzy.eval(mf, l_vertex) == Fuzzy.eval(mf, r_vertex) == 0.0
-@assert Fuzzy.eval(mf, (l_vertex + center) / 2.0) == Fuzzy.eval(mf, (r_vertex + center) / 2.0) == 0.5
+@assert Fuzzy.evaluate(mf, center) == 1
+@assert Fuzzy.evaluate(mf, l_vertex) == Fuzzy.evaluate(mf, r_vertex) == 0.0
+@assert Fuzzy.evaluate(mf, (l_vertex + center) / 2.0) == Fuzzy.evaluate(mf, (r_vertex + center) / 2.0) == 0.5
 
 # Mean finding tests
 @assert Fuzzy.mean_at(mf, 1.0) == center
-@assert Fuzzy.mean_at(mf, 0.0) == (l_vertex + r_vertex) / 2.0
\ No newline at end of file
+@assert Fuzzy.mean_at(mf, 0.0) == (l_vertex + r_vertex) / 2.0