rfuzzy 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,9 @@
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

data/README.rdoc

@@ -0,0 +1,33 @@
+= rfuzzy
+
+Rfuzzy is a small, yet handy tool for express creation of fuzzy systems.
+It's goal is to provide a quick way for defining any kind of expert system.
+
+== Features
+
+Adherence functions
+* Easy creation of any adherence function.
+* Performing t and s norms on functions.
+* Defuzzification.
+
+Fuzzy domains (fuzzy sets)
+* Easy creation of domains.
+* Domains described by named adherence functions.
+
+Fuzzy rules
+* Syntax similar to natural language.
+* Proc's used as both antecendent and consequent of a rule.
+
+Fuzzy systems
+* Easy definition of input and output variables.
+* Easy definition of rules
+
+== Tutorials
+
+More information can be found at:
+http://student.agh.edu.pl/~majta/rfuzzy
+
+== Copyright
+
+This software is distributed under JSON License:
+http://www.json.org/license.html

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rfuzzy"
+  gem.homepage = "http://github.com/lolek09/rfuzzy"
+  gem.license = "JSON"
+  gem.summary = %Q{rfuzzy is a fuzzy logic library for Ruby}
+  gem.description = %Q{rfuzzy is a fuzzy logic library for Ruby}
+  gem.email = "karolmajta@gmail.com"
+  gem.authors = ["lolek09"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rfuzzy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rfuzzy.rb

@@ -0,0 +1,17 @@
+#get current dir
+require 'pathname'
+current_dir = Pathname.new(File.dirname(__FILE__))
+# mixins
+require current_dir + "rfuzzy/norm"
+require current_dir + "rfuzzy/defuzz"
+# classes
+require current_dir + "rfuzzy/point"
+require current_dir + "rfuzzy/function"
+require current_dir + "rfuzzy/adherence"
+require current_dir + "rfuzzy/fuzzy_domain"
+require current_dir + "rfuzzy/fuzzy_variable"
+require current_dir + "rfuzzy/rule"
+require current_dir + "rfuzzy/fuzzy_system"
+# helper classes
+require current_dir + "rfuzzy/trapezoidal"
+require current_dir + "rfuzzy/triangular"

data/lib/rfuzzy/adherence.rb

@@ -0,0 +1,51 @@
+# Adherence. Basically it's a Float in range [0;1] allowing norm operations.
+class Adherence
+	include Norm
+	
+	# Constructor. Usage
+	# <tt>.new(Float value)</tt>
+	# Value must be [0;1]
+	def initialize(val)
+		if val < 0 || val > 1
+			raise ArgumentError, "Adherence must be in [0;1]"
+		end
+		@adh = val
+	end
+	
+	def to_f
+		return @adh
+	end
+	
+	# Performs t-norm on itself and other. Usage:
+	# <tt>.and(Adherence other, Symbol method)
+	# <tt>.and(Adherence other)
+	def and(other, method = :auto)
+		if(method == :auto)
+			unless @@norm_method.nil?
+				method = @@norm_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		return Adherence.new(self.method(NORM_METHODS[method][:t]).call(self.to_f, other.to_f))
+	end
+	
+	# Performs s-norm on itself and other. Usage:
+	# <tt>.or(Adherence other, Symbol method)
+	# <tt>.or(Adherence other)
+	def or(other, method = :auto)
+		if(method == :auto)
+			unless @@norm_method.nil?
+				method = @@norm_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		return Adherence.new(self.method(NORM_METHODS[method][:s]).call(self.to_f, other.to_f))
+	end
+	
+	# Performs negation.
+	def not
+		return Adherence.new(1 - @value)
+	end
+end

data/lib/rfuzzy/defuzz.rb

@@ -0,0 +1,91 @@
+module Defuzz
+	DEFUZZ_METHODS = {
+		:lom => :least_of_maximum,
+		:mom => :middle_of_maximum,
+		:bom => :biggest_of_maximum,
+		:aom => :average_of_maximum,
+		:cog => :center_of_gravity
+	}
+
+	@@defuzz_method = nil
+	
+	# Sets the method for defuzzification. Avalaible norms are defined in <em>DEFUZZ_METHODS</em>
+	def Defuzz.defuzz_method(m)
+		if DEFUZZ_METHODS.has_key?(m)
+			@@defuzz_method = m
+		else
+			sm = ""
+			DEFUZZ_METHODS.each_key do |k|
+				sm << "#{k} "
+			end
+			raise ArgumentError, "defuzzification method #{m} is not supported\nSupported methods: #{sm}"
+		end
+	end
+	
+	private
+	
+	def least_of_maximum(fun)
+		found = fun.points[0]
+		fun.points.each do |p|
+			found = p if p.y > found.y
+		end
+		return found
+	end
+	
+	def middle_of_maximum(fun)
+		found = []
+		found.push fun.points[0]
+		fun.points[1..fun.points.length].each do |p|
+			if p.y == found[0].y
+				found.push p
+			end
+			if p.y > found[0].y
+				found.clear
+				found.push p
+			end
+		end
+		return found[found.length/2]
+	end
+	
+	def biggest_of_maximum(fun)
+		found = fun.points[0]
+		fun.points.each do |p|
+			found = p if p.y >= found.y
+		end
+		return found
+	end
+	
+	def average_of_maximum(fun)
+		found = []
+		found.push fun.points[0]
+		fun.points[1..fun.points.length].each do |p|
+			if p.y == found[0].y
+				found.push p
+			end
+			if p.y > found[0].y
+				found.clear
+				found.push p
+			end
+		end
+		sum = 0
+		found.each do |p|
+			sum += p.x
+		end
+		average = sum / found.length.to_f
+		return Point.new(average, fun.at(average))
+	end
+	
+	def center_of_gravity(fun)
+		sum_xy = 0
+		sum_y = 0
+		fun.points.each do |p|
+			sum_xy += p.x*p.y
+			sum_y += p.y
+		end
+		if sum_y == 0
+			return fun.points[fun.points.lenght/2]
+		else
+			Point.new(sum_xy/sum_y, fun.at(sum_xy/sum_y))
+		end
+	end
+end

data/lib/rfuzzy/function.rb

@@ -0,0 +1,220 @@
+# Basic 2d adherence function
+class Function
+	include Norm
+	include Defuzz
+	
+	EPSILON = 1.0e-10
+	
+	@@step_size = nil
+	
+	# Sets the step resolution used if automatic step detection is used
+	def self.step_size(s)
+		if s <= 0
+			raise ArgumentError, "Step size must be greater than 0"
+		else
+			@@step_size = s
+		end
+	end
+	
+	attr_accessor :name, :points
+	
+	#Default constructor. Usage:
+	#<tt>.new(String name, Point *points)</tt>
+	def initialize(name,*args, &block)
+		@name = name
+		@points = args
+		if block_given?
+			yield self
+		end
+		@points.sort
+	end
+	
+	# Copy constructor.
+	def initialize_copy(other, &block)
+		initialize(other.name, other.points, block)
+	end
+	
+	def to_s
+		str = "ADHERENCE FUNCTION\n\tPoints:\n"
+		@points.each do |point|
+			str << "\t#{point}\n"
+		end
+		return str
+	end
+	
+	# For use with GNUplot
+	def to_gplot
+		str = ""
+		@points.each do |p|
+			str << "#{p.x} #{p.y}\n"
+		end
+		return str
+	end
+	
+	# Returns a new Function with y coordinate multiplied by the given factor.
+	# If the new y value is greater than one 1.0 is assigned. This can be used
+	# for product-like Mamdani rules.
+	# Usage:
+	# <tt>.*(Float factor)</tt>
+	def *(fl)
+		fl = fl.to_f
+		unless fl >= 0
+			raise ArgumentError, "Argument should be positive"
+		end
+		new_function = Function.new("#{@name}*#{fl}")
+		@points.each do |p|
+			new_function.points.push Point.new(p.x, [p.y*fl, 1.0].max)
+		end
+		return new_function
+	end
+	
+	# Returns a new Function with y coordinate less than given factor.
+	# This can be used
+	# for max-min-like Mamdani rules.
+	# Usage:
+	# <tt>.cut_at(Float factor)</tt>
+	def cut_at(fl)
+		unless fl >= 0 && fl <= 1
+			raise ArgumentError, "Argument should be from [0;1]"
+		end
+		new_function = Function.new("#{@name} MAX #{fl}")
+		@points.each do |p|
+			puts "#{fl} #{p.y}"
+			new_function.points.push Point.new(p.x, [p.y,fl].min)
+		end
+		return new_function
+	end
+	
+	# Adds points to the function. Usage:
+	# <tt>.add(Point *points)</tt>
+	def add(*points)
+		points.each do |p|
+			if @points.include? p
+				@points.delete p
+			end
+		end
+		@points.concat points
+		@points.sort!
+	end
+	
+	# Removes points from the function. Usage:
+	# <tt>.remove(Point *points)</tt>
+	def remove(*points)
+		points.each do |p|
+			@points.delete p
+		end
+	end
+	
+	# Calculates function value at x using linear approximation. Function boundaries are from -Infinity to +Infinity.
+	# Usage:
+	# <tt>.at(Float x)</tt>
+	def at(x)
+		if @points.first.x >= x
+			return @points.first.y
+		elsif @points.last.x <= x
+			return @points.last.y
+		else
+			@points.each_index do |i|
+				if x >= @points[i].x && x < @points[i+1].x
+					dy = @points[i+1].y - @points[i].y
+					dx = @points[i+1].x - @points[i].x
+					du = (dy/dx)*(x - @points[i].x)
+					return @points[i].y + du 
+				end
+			end
+		end
+	end
+	
+	# Method for performing and (t-norm) operation.
+	# Usage:
+	# <tt>.and(Function f, Float step, Symbol method)
+	# <tt>.and(Function f, Float step)
+	# <tt>.and(Function f)
+	def and(other, step = :auto, method = :auto)
+		res = apply_norm(:t, other, step, method)
+		if block_given?
+			yield res
+		end
+		return res
+	end
+	
+	# Method for performing or (s-norm) operation.
+	# Usage:
+	# <tt>.or(Function f, Float step, Symbol method)
+	# <tt>.or(Function f, Float step)
+	# <tt>.or(Function f)
+	def or(other, step = :auto, method = :auto)
+		res = apply_norm(:s, other, step, method)
+		if block_given?
+			yield res
+		end
+		return res
+	end
+	
+	# Negation. Usage:
+	# .not
+	def not(&block)
+		new_function = Function.new("not #{@name}")
+		@points.each_index do |i|
+			new_function.points[i] = Point.new(@points[i].x, 1 - @points[i].y)
+		end
+		if block_given?
+			yield new_function
+		end
+		return new_function
+	end
+	
+	# defuzzification
+	def defuzz(method = :auto)
+		if(method == :auto)
+			unless @@defuzz_method.nil?
+				method = @@defuzz_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		method(DEFUZZ_METHODS[method]).call(self)
+	end
+	
+	private
+	
+	# Actually does the norm
+	def apply_norm(norm, other, step = :auto, method = :auto)
+		if(step == :auto)
+			unless @@step_size.nil?
+				step = @@step_size
+			else
+				raise ArgumentError, "Specify step, or call Function::step_size"
+			end
+		end
+		if(method == :auto)
+			unless @@norm_method.nil?
+				method = @@norm_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		if(norm == :t)
+			op = "and"
+		elsif(norm == :s)
+			op = "or"
+		else
+			raise ArgumentError, "norm for Norm#apply_form must be :t or :s"
+		end
+		new_function = Function.new("(#{@name} #{op} #{other.name})")
+		start_point = [@points.min,other.points.min].min
+		stop_point = [@points.max,other.points.max].max
+		i = start_point.x
+		x = []
+		y = []
+		while(stop_point.x - i >= 0 - EPSILON)
+			x.push i 
+			y.push method(NORM_METHODS[method][norm]).call(self.at(i), other.at(i))
+			i += step
+		end
+		x.each_index do |index|
+			new_function.points[index] = Point.new(x[index],y[index])
+		end
+		return new_function
+	end
+end

data/lib/rfuzzy/fuzzy_domain.rb

@@ -0,0 +1,36 @@
+# Class for defining fuzzy domains.
+class FuzzyDomain
+	attr_reader :adherence_functions
+	
+	# Constructor.
+	def initialize(*functions, &block)
+		@adherence_functions = {}
+		functions.each do |f|
+			unless @adherence_functions.has_key?(f.name)
+				@adherence_functions[f.name] = function
+			else
+				raise ArgumentError, "Lexical variable '#{f.name}' already describes this FuzzyVar!"
+			end	
+		end
+		if block_given?
+			yield self
+		end
+	end
+	
+	# Allows adding adherence functions with lexical variables describing the domain
+	def is_described_by(function, &block)
+		if block_given?
+			yield function
+		end
+		unless @adherence_functions.has_key?(function.name)
+			@adherence_functions[function.name] = function
+		else
+			raise ArgumentError, "Lexical variable '#{function.name}' already describes this FuzzyVar!"
+		end
+	end
+	
+	# Removes adherence functions and lexical variables
+	def is_not_described_by(name)
+		@adherence_functions.delete(name)
+	end
+end

data/lib/rfuzzy/fuzzy_system.rb

@@ -0,0 +1,107 @@
+# Used for representing expert system of any kind
+class FuzzySystem
+	@domains
+	@inputs
+	@outputs
+	@defaults
+	@rules
+	
+	# Constructor - yields self. Usage:
+	# <tt>.new()</tt>
+	def initialize
+		@domains = {}
+		@inputs = {}
+		@outputs = {}
+		@defaults = {}
+		@rules = []
+		if block_given?
+			yield self
+		end
+	end
+	
+	# Declare an input in the system. This will result in creating
+	# i_[name] and i_[name]= used for getting and setting the values
+	# for this input. Usage:
+	# <tt>.input(String name, FuzzyDomain domain)</tt>
+	def  input(name, domain)
+		@domains[name] = domain
+		
+		body = Proc.new do
+			@inputs[name]
+		end
+		self.class.send(:define_method, "i_#{name}", body)
+		
+		body = Proc.new do |val|
+			@inputs[name] = val
+		end
+		self.class.send(:define_method, "i_#{name}=", body)
+	end
+	
+	# Declare an an output in the system. This will result in creating
+	# o_[name] and o_[name]= used for getting and setting the values
+	# for this output. Usage:
+	# <tt>.output(String name, FuzzyDomain domain)</tt>
+	def output(name, default = nil)
+		@defaults[name] = default
+		
+		body = Proc.new do
+			unless @outputs[name].nil?
+				@outputs[name]
+			else
+				@defaults[name]
+			end
+		end
+		self.class.send(:define_method, "o_#{name}", body)
+		
+		body = Proc.new do |val|
+			@outputs[name] = val
+		end
+		self.class.send(:define_method, "o_#{name}=", body)
+	end
+	
+	# Used for adding rules to the system. Usage:
+	# <tt>.rule(Proc antecendent, Proc consequent)</tt>
+	def rule(ant, cons)
+		r = Rule.new(ant, cons)
+		@rules.push r
+		return @rules[@rules.length-1]
+	end
+	
+	# Used for pushing input into the system. Takes a dict in which
+	# keys are declared input names, and values are current values (FuzzyVariables).
+	# This method performs a check if given data matches the one declared for the system.
+	# Usage:
+	# <tt>.inject(Hash inputs)</tt>
+	def inject(dict)
+		unless dict.keys == @domains.keys
+			raise ArgumentError, 'Input dictionary does not match the system inputs'
+		end
+		dict.each do |key, value|
+			if value.respond_to? :domain=
+				value.domain = @domains[key]
+			end
+		end
+		@inputs = dict
+	end
+	
+	# Returns a dict of all calculated outputs.
+	# Usage:
+	# <tt>.eject()</tt>
+	def eject
+		return @outputs
+	end
+	
+	# Resets all outputs. Usage:
+	# <tt>.reset()</tt>
+	def reset
+		@outputs = {}
+	end
+	
+	# Calls .apply on every rule in the system in order they were declared. Usage:
+	# <tt>.process()</tt>
+	def	process
+		@rules.each do |r|
+			r.apply
+		end
+	end
+end

data/lib/rfuzzy/fuzzy_variable.rb

@@ -0,0 +1,59 @@
+# Represents fuzzy value belonging to a specific domain. Calculates the adherence on demand.
+class FuzzyVariable
+	include Norm
+	
+	attr_accessor :value, :domain
+	
+	# Constructor. Usage
+	# <tt>.new(Float value)</tt>
+	def initialize(val, &block)
+		@value = val.to_f
+		if block_given?
+			yield self
+		end
+	end
+	
+	def to_f
+		return @value
+	end
+	
+	# returns new FuzzyVariable with value multiplied by float
+	# <tt>.*(float)</tt>
+	def *(float)
+		return FuzzyVariable.new(@value*float.to_f, @domain)
+	end
+	
+	# Calculates the adherence of variable. Usage:
+	# <tt>.is(String lex_var, Symbol method)</tt>
+	# <tt>.is(String lex_var)
+	def is(lex_var, method = :auto)
+		if(method == :auto)
+			unless @@norm_method.nil?
+				method = @@norm_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		if @domain.adherence_functions.has_key? lex_var
+			return Adherence.new(@domain.adherence_functions[lex_var].at(@value))
+		else
+			raise ArgumentError, "Specified adjective '#{lex_var}' does not belong to variable's domain"
+		end
+	end
+	
+	# Calculates negation of variables adherence. Usage - same as .is
+	def is_not(lex_var, method = :auto)
+		if(method == :auto)
+			unless @@norm_method.nil?
+				method = @@norm_method
+			else
+				raise ArgumentError, "Specify method, or call Norm::norm_method"
+			end
+		end
+		if @domain.adherence_functions.has_key? lex_var
+			return Adherence.new(1-@domain.adherence_functions[lex_var].at(@value))
+		else
+			raise ArgumentError, "Specified adjective does not belong to variable's domain"
+		end
+	end
+end

data/lib/rfuzzy/norm.rb

@@ -0,0 +1,42 @@
+# Module with t-norms and s-norms
+module Norm
+	NORM_METHODS = {
+		:maxmin => {:t => :t_norm_max_min, :s => :s_norm_max_min},
+		:prob => {:t => :t_norm_prob, :s => :s_norm_prob}
+	}
+	
+	@@norm_method = nil
+	
+	# Sets the method for norms. Valid methods are keys in <em>NORM_METHODS</em>
+	def Norm.norm_method(m)
+		if NORM_METHODS.has_key?(m)
+			@@norm_method = m
+		else
+			sm = ""
+			NORM_METHODS.each_key do |k|
+				sm << "#{k} "
+			end
+			raise ArgumentError, "method #{m} is not supported for t-norms and s-norms\nSupported methods: #{sm}"
+		end
+	end
+	
+	# Max/min t-norm
+	def t_norm_max_min(x,y)
+		return [x,y].min
+	end
+	
+	# Max/min s-norm
+	def s_norm_max_min(x,y)
+		return [x,y].max
+	end
+	
+	# Probablistic t-norm
+	def t_norm_prob(x,y)
+		return x*y
+	end
+	
+	# Probablistic s-norm
+	def s_norm_prob(x,y)
+		return x+y-x*y
+	end
+end

data/lib/rfuzzy/point.rb

@@ -0,0 +1,31 @@
+# Point used for adherence functions.
+# Should not be thought of as a point-in-space.
+class Point
+	include Comparable
+
+	attr_accessor :x, :y
+	# Constructor. Usage:
+	# <tt>.new(Float x, Float y)</tt>
+	# y must be [0;1]
+	def initialize(x, y)
+		@x = x.to_f
+		if y < 0 || y > 1
+			raise RangeError, "Function values for fuzzy sets must be from [0;1]", caller
+		end
+		@y = y.to_f
+	end
+	
+	def to_s
+		return "(#{@x},#{@y})"
+	end
+	
+	# Convenient for use with GNUplot.
+	def to_gplot
+		return "#{@x} #{@y}\n"
+	end
+	
+	# This is here only for sorting, should not be used for 'real' comparsion
+	def <=>(other)
+		@x <=> other.x
+	end
+end

data/lib/rfuzzy/rule.rb

@@ -0,0 +1,21 @@
+# Represents the Rule for FuzzySystem where both antescendent and consequent are Proc objects
+class Rule
+	@antecendent
+	@consequent
+	
+	# Usage:
+	# <tt>.new(Proc antecentent, Proc consequent)</tt>
+	def initialize(ant, cons)
+		@antecendent = ant
+		@consequent = cons
+	end
+	
+	# Calls antecentent and then calls consequent
+	# passing the result from antecendent to consequent.
+	# In most cases the passed value is Adherence.
+	# Usage:
+	# <tt>.apply()</tt>
+	def apply
+		@consequent.call(@antecendent.call)
+	end
+end

data/lib/rfuzzy/trapezoidal.rb

@@ -0,0 +1,9 @@
+# Trapezoidal adherence function
+class Trapezoidal < Function
+	#Default constructor. Creates the trapezoidal function. Order of arguments is irrelevant. They will be sorted in ascending order.
+	#<tt>.new(Float a, Float b, Float c, Float d)</tt>
+	def initialize(name, a, b, c, d)
+		p = [a,b,c,d].sort
+		super(name, Point.new(p[0],0),Point.new(p[1],1),Point.new(p[2],1),Point.new(p[3],0))
+	end
+end

data/lib/rfuzzy/triangular.rb

@@ -0,0 +1,9 @@
+# Triangular adherence function
+class Triangular < Function
+	#Default constructor. Creates the trapezoidal function. Order of arguments is irrelevant. They will be sorted in ascending order.
+	#<tt>.new(Float a, Float b, Float c)</tt>
+	def initialize(name, a, b, c)
+		p = [a,b,c].sort
+		super(name, Point.new(p[0],0),Point.new(p[1],1),Point.new(p[2],0))
+	end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rfuzzy'
+
+class Test::Unit::TestCase
+end

data/test/test_rfuzzy.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRfuzzy < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: rfuzzy
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- lolek09
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: shoulda
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 6
+        - 2
+        version: 1.6.2
+  name: jeweler
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id004
+description: rfuzzy is a fuzzy logic library for Ruby
+email: karolmajta@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rfuzzy.rb
+- lib/rfuzzy/adherence.rb
+- lib/rfuzzy/defuzz.rb
+- lib/rfuzzy/function.rb
+- lib/rfuzzy/fuzzy_domain.rb
+- lib/rfuzzy/fuzzy_system.rb
+- lib/rfuzzy/fuzzy_variable.rb
+- lib/rfuzzy/norm.rb
+- lib/rfuzzy/point.rb
+- lib/rfuzzy/rule.rb
+- lib/rfuzzy/trapezoidal.rb
+- lib/rfuzzy/triangular.rb
+- test/helper.rb
+- test/test_rfuzzy.rb
+has_rdoc: true
+homepage: http://github.com/lolek09/rfuzzy
+licenses: 
+- JSON
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: rfuzzy is a fuzzy logic library for Ruby
+test_files: []
+