fuzzyfic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec4b2dd6e2502179b84e960af4bdfd5929c97d23
+  data.tar.gz: 3b99b85098eaf5b2a4ae6c6f222b22ffc894a7c0
+SHA512:
+  metadata.gz: cf5255c1018b0635b0df0eabfb053f979d20ef9dc06081e250efb045fb1009d4084c6f9ad137b6b2df234f6f273b8a412c0476abe4aef97d38d909e5105e1d40
+  data.tar.gz: 109b569c912f5e698dce5c81dcb94ce4669f4f71aaba5bb2d672d9f52e621cda68c478f49edb6e4d8391916660b0352190c38e06bdb376d635d32c292cdba6fb

data/README.md

@@ -0,0 +1,40 @@
+#Fuzzyfic
+Fuzzy logic with ruby
+
+##Example
+```ruby
+# Input 1 : Service quality
+service_quality = {
+	bad: Fuzzyfic::Gaussian.new([0,10], 0, 1.5), # => support=[0,10], center=0, width=1.5, using [exp(-((x-center)^2)/(2*width^2))]
+	good: Fuzzyfic::Gaussian.new([0,10], 5, 1.5),
+	excellent: Fuzzyfic::Gaussian.new([0,10], 10, 1.5)
+}
+
+# Input 2 : Food
+food = {
+	execrable: Fuzzyfic::Trapezoid.new([0,3], [0,1]),
+	delicious: Fuzzyfic::Trapezoid.new([7,10], [9,10])
+}
+
+# Output : Tips
+tips = {
+	low: Fuzzyfic::Triangle.new([0,10], 5), # => support=[0,10], kernel/center/peak=5
+	average: Fuzzyfic::Triangle.new([10,20], 15),
+	high: Fuzzyfic::Triangle.new([20,30], 25)
+}
+
+
+# Rules
+rules = []
+rules.push service_quality[:bad].or(food[:execrable]).then tips[:low] # => If the service_quality is bad or the food is execrable, then the tips are low
+rules.push service_quality[:good].then tips[:average]
+rules.push service_quality[:excellent].or(food[:delicious]).then tips[:high]
+
+
+# Apply Rules, using Centroid/COG method
+Fuzzyfic::Defuzzifier.cog(rules, 6.19, 8.42)# Print 19.97 => (service_quality=6.19, food=8.42) => tips=19.97
+```
+
+<p align="center">
+	<img src="examples/tips.png" alt="3D result" />
+</p>

data/lib/fuzzyfic.rb

@@ -0,0 +1,11 @@
+require_relative 'fuzzyfic/set.rb'
+require_relative 'fuzzyfic/trapezoid.rb'
+require_relative 'fuzzyfic/triangle.rb'
+require_relative 'fuzzyfic/condition.rb'
+require_relative 'fuzzyfic/rule.rb'
+require_relative 'fuzzyfic/defuzzifier.rb'
+require_relative 'fuzzyfic/gaussian.rb'
+
+
+module FuzzyLogic
+end

data/lib/fuzzyfic/condition.rb

@@ -0,0 +1,35 @@
+require_relative 'rule'
+
+module Fuzzyfic
+	class Condition
+
+		attr_accessor :left, :right, :operator
+
+		def initialize left, right=nil, operator=nil
+			@left = left
+			@right = right
+			@operator = operator
+		end
+
+		def then set
+			Rule.new self, set
+		end
+
+		def apply v_left, v_right=nil
+			img_left = @left.get v_left
+			img_right = @right.get v_right if !@right.nil?
+
+			case @operator
+			when nil
+				img_left
+			when :and
+				[img_left, img_right].min
+			when :or
+				[img_left, img_right].max
+			when :not
+				1.0 - img_left
+			end
+		end
+
+	end
+end

data/lib/fuzzyfic/defuzzifier.rb

@@ -0,0 +1,45 @@
+module Fuzzyfic
+	class Defuzzifier
+
+		def self.cog rules, i1, i2
+			## Compute intermediate results for every rules
+			intermediate = []
+			rules.each do |r|
+				intermediate.push r.apply(i1, i2)
+			end
+			
+
+			## COG method (centroid)
+
+			# compute support interval
+			mins = []
+			maxs = []
+			intermediate.each do |i|
+				mins.push i.first.support.min
+				maxs.push i.first.support.max
+			end
+
+			support_min = mins.min
+			support_max = maxs.max
+
+
+			# compute cog : \frac{\sum_{x \in support} x*f(x)}{\sum_{x \in support} f(x)}
+			num = denum = 0.0
+			for x in (support_min..support_max).step(0.1)
+
+				# compute f(x) : get the maximum from all conclusion rules (as a fusion)
+				images = []
+				intermediate.each do |i|
+					images.push i.first.get_in_crop(x, i.last)
+				end
+				fx = images.max
+
+				num += x*fx
+				denum += fx
+			end
+
+			return denum.zero? ? 0.0 : num/denum
+		end
+
+	end
+end

data/lib/fuzzyfic/gaussian.rb

@@ -0,0 +1,18 @@
+require_relative 'set'
+
+module Fuzzyfic
+	class Gaussian < Set
+
+		def initialize support, center, width 
+			super()
+			@support = support
+			@center = center
+			@width = width
+		end
+
+		def get x
+			return 0.0 if !x.between?(@support.first, @support.last)
+			Math.exp(-((x-@center)**2)*1.0/(2*@width**2))
+		end
+	end
+end

data/lib/fuzzyfic/rule.rb

@@ -0,0 +1,15 @@
+module Fuzzyfic
+	class Rule
+
+		def initialize premise, conclusion 
+			@premise = premise
+			@conclusion = conclusion
+		end
+
+		def apply v_left, v_right=nil
+			alpha = @premise.apply v_left, v_right
+			[@conclusion, alpha]
+		end
+
+	end
+end

data/lib/fuzzyfic/set.rb

@@ -0,0 +1,35 @@
+require_relative 'condition'
+require_relative 'rule'
+
+module Fuzzyfic
+	class Set
+
+		attr_accessor :support
+
+		def initialize 
+		end
+
+		def and set
+			Condition.new self, set, :and
+		end
+
+		def or set
+			Condition.new self, set, :or
+		end
+
+
+		def then set
+			condition = Condition.new self
+			Rule.new condition, set
+		end
+
+		# Must be overriden in sub-classes
+		def get x		
+		end
+
+		def get_in_crop x, alpha
+			[get(x), alpha].min
+		end
+
+	end
+end

data/lib/fuzzyfic/trapezoid.rb

@@ -0,0 +1,28 @@
+require_relative 'set'
+
+module Fuzzyfic
+	class Trapezoid < Set
+
+		def initialize support, kernel
+			super()
+			@support = support
+			@kernel = kernel
+		end
+
+		def get x
+			return 0.0 if !x.between?(@support.first, @support.last)
+			return 1.0 if x.between?(@kernel.first, @kernel.last)
+
+			if x < @kernel.first
+				a = 1.0/(@kernel.first - @support.first)
+				b = 1.0 - a*@kernel.first
+				return a*x + b
+			elsif x > @kernel.last
+				a = -1.0/(@support.last - @kernel.last)
+				b = 1.0 - a*@kernel.last
+				return a*x + b
+			end
+		end
+
+	end
+end

data/lib/fuzzyfic/triangle.rb

@@ -0,0 +1,27 @@
+require_relative 'set'
+
+module Fuzzyfic
+	class Triangle < Set
+
+		def initialize support, center
+			super()
+			@support = support
+			@center = center
+		end
+
+		def get x
+			return 0.0 if !x.between?(@support.first, @support.last)
+			return 1.0 if x == @center
+
+			if x < @center
+				a = 1.0/(@center - @support.first)
+				b = 1.0 - a*@center
+				return a*x + b
+			elsif x > @center
+				a = -1.0/(@support.last - @center)
+				b = 1.0 - a*@center
+				return a*x + b
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: fuzzyfic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jerome Boe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-02 00:00:00.000000000 Z
+dependencies: []
+description: Fuzzy Logic in Ruby Language
+email:
+- jeromeboe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/fuzzyfic.rb
+- lib/fuzzyfic/condition.rb
+- lib/fuzzyfic/defuzzifier.rb
+- lib/fuzzyfic/gaussian.rb
+- lib/fuzzyfic/rule.rb
+- lib/fuzzyfic/set.rb
+- lib/fuzzyfic/trapezoid.rb
+- lib/fuzzyfic/triangle.rb
+homepage: https://github.com/jeromeboe/fuzzyfic
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.2
+signing_key: 
+specification_version: 4
+summary: Fuzzy Logic in Ruby Language
+test_files: []