graphkit 0.1

data/lib/graphkit.rb

@@ -0,0 +1,852 @@
+script_folder = File.dirname(File.expand_path(__FILE__))
+
+require 'pp'
+require script_folder + '/box_of_tricks.rb'
+require script_folder + '/gnuplot.rb'
+
+class Matrix
+	def shape
+		return[row_size, column_size]
+	end
+end
+
+class Hash
+	def modify(hash, excludes=[])
+		hash.each do |key, value|
+# 			p key
+# 			ep key, value if value #if option == :xrange
+
+			begin
+				self[key] = value.dup unless excludes.include? key
+			rescue TypeError #immediate values cannot be dup'd
+				self[key] = value unless excludes.include? key
+			end
+		end
+		self
+	end
+	alias :absorb :modify
+end
+
+# class Array
+# 	def to_sparse_tensor_key
+# 		return SparseTensor::Key.new)
+# 	end
+# end
+
+
+# A simple sparse tensor
+
+class SparseTensor < Hash
+	class RankError < StandardError
+	end
+	
+# 	class Key < Array
+# 		def ==
+# 			
+# 	end
+	
+	
+	attr_reader :rank, :shape
+	
+	# Create a new tensor.
+	
+	def initialize(rank = 2)
+		@rank = rank
+		@shape = [0]*rank
+		super()
+	end
+	
+	# Create a new diagonal tensor from an array. E.g. if rank was 2, then 
+	# 	tensor[0,0] = array[0]
+	# 	tensor[1,1] = array[1]
+	# Etc.
+	
+	def self.diagonal(rank, array)
+		tensor = new(rank)
+		for index in 0...array.size
+			tensor[[index] * rank] = array[index]
+		end
+		tensor
+	end
+	
+	# Access an element of the tensor. E.g. for a rank 2 tensor
+	#
+	# 	a = tensor[1,3]
+	
+	def [](*args)
+		args = args[0] if args.size == 1 and not args.size == @rank and args[0].size == @rank
+# 		p args
+
+		raise RankError.new("Rank is #@rank, not #{args.size}") unless args.size == @rank
+		return super(args)
+	end
+	
+	# Set an element of the tensor. E.g. for a rank 2 tensor
+	#
+	# 	tensor[1,3] = a_variable
+	
+	def []=(*args)
+		value = args.pop
+		args = args[0] if args.size == 1 and args[0].size == @rank
+		raise RankError.new("Rank is #@rank, not #{args.size}") unless args.size == @rank
+		args.each_with_index do |arg, index|
+			@shape[index] = [@shape[index], arg + 1].max
+		end
+		super(args, value)
+	end
+	
+	# Perform some action involving all the elements of this tensor and another.
+	# 
+	# E.g.
+	# 	tensor_1.scalar_binary(tensor_2) do |element_1, element_2|
+	# 		element_1 + element_2
+	# 	end
+	#
+	# will add every element of tensor_1 to every corresponding element of tensor_2.
+			
+	
+	
+	def scalar_binary(other, &block)
+		raise ArgumentError unless other.class == self.class
+		raise RankError.new("Different ranks: #@rank, #{other.rank}") unless other.rank == @rank
+
+		new = self.class.new(@rank)
+		self.keys.each do |key|
+			if other[key]
+				new[key] = yield(self[key], other[key])
+			else
+				new[key] = self[key]
+			end
+		end
+		(other.keys - self.keys).each{|key| new[key] = other[key]}
+		new
+	end
+	def +(other)
+		scalar_binary(other){|a, b| a + b}
+	end
+	def -(other)
+		scalar_binary(other){|a, b| a - b}
+	end
+	
+	# Find the maximum element of the tensor. See Enumerable#max.
+	
+	def max(&block)
+		return self.values.max(&block)
+	end
+	
+	# Find the minimum element of the tensor. See Enumerable#max.
+	
+	def min(&block)
+		return self.values.min(&block)
+	end
+
+
+	
+end
+
+	
+	
+
+# To be mixed in to a Hash. Basically allows access the elements of a hash via method names rather than brackets.
+
+
+module Kit
+	
+	class IntegrityError < StandardError
+	end
+	
+	def method_missing(method, *args)
+# 		p method, args
+		m = method.to_s
+		if m =~ /=$/
+			name = m.chop.to_s
+			self.class.send(:define_method, method){|arg| self[name.to_sym] = arg}
+			return send(method, args[0])
+		else
+			self.class.send(:define_method, method){self[method]}
+			return send(method)
+		end
+	end
+	
+	def check(*values, &block)
+		values.each do |arr|
+			case arr.size 
+			when 2
+				expression, test_data = arr
+				if block
+					raise IntegrityError.new("#{expression} failed argument correctness test (value given was '#{self[expression].inspect}')") unless yield(instance_eval(expression), test_data)
+				else
+					is_array = test_data.class == Array
+					raise IntegrityError.new("#{expression} was  #{instance_eval(expression)} instead of #{test_data.inspect}") unless (is_array ? test_data.include?(instance_eval(expression)) : instance_eval(expression) == test_data)
+				end
+			when 3
+				string, value, test_data = arr
+				if block
+					raise IntegrityError.new("#{string} failed argument correctness test (value given was '#{value.inspect}')") unless yield(value, test_data)
+				else
+					is_array = test_data.class == Array
+					raise IntegrityError.new("#{string} was #{value.inspect} instead of #{test_data.inspect}") unless (is_array ? test_data.include?(value) : value == test_data)
+				end
+			else
+				raise "Bad value checking data: #{arr.inspect}"
+			end
+		end
+	end
+	
+	
+	
+
+	
+end
+
+# See Kit
+
+class KitHash < Hash
+	include Kit
+	aliold :inspect
+	def inspect
+		return (%[#{self.class}.from_hash(#{old_inspect})])
+	end
+	def self.from_hash(hash)
+		kit = new
+		hash.each do |key, val|
+			kit[key] = val
+		end
+		kit
+	end
+end
+
+# A GraphKit is 'a complete kit of things needed to make a graph'. By graph, a 1d, 2d, 3d, or 4d (3 + colouring/shading) visualisation is meant. The first thee axes are given the traditional labels :x, :y, :z, and the fourth :f, meaning fill, or function.
+#
+# Time variation can be can be achieved by an array of GraphKits each at a different time.
+#
+# A GraphKit is a hash where some of the keys must be specific things, and it provides a method, check_integrity, to ensure that the keys are assigned correctly. This method also checks that dimensions and ranks of all the data are consistent, allowing a graph to be plotted.
+#
+# GraphKit also allows you access any property, e.g. title, as
+#
+#	graphkit.title
+#	
+#	graphkit.title = 
+#
+# as well as the hash form:
+#
+#	graphkit[:title]
+#	graphkit[:title] =
+# 
+# GraphKits have methods which allow the graphs to be rendered using standard visualisation packages. At present only gnuplot is supported, but others are planned.
+#
+# GraphKits overload certain operators, for example <tt>+</tt>, which mean that they can be combined easily and intuitively. This makes plotting graphs from different sets of results on the same page as easy as adding 2+2!
+# 
+# GraphKits define a minimum set of keys which are guaranteed to be meaningful and work on all platforms. If you stick to using just these properties, you'll be able to easily plot basic graphs. If you need more control and customisation, you need to look at the documentation both for the visualisation package (e.g. gnuplot) and the module which allows a GraphKit to interface with that package (e.g. GraphKit::Gnuplot).
+#
+# Here is the specification for the standard keys:
+# 
+# * title (String): the title of the graph
+# * xlabel, ylabel, zlabel (String): axis labels
+# * xrange, yrange, zrange, frange (Array): ranges of the three dimensions and possibly the function as well.
+# * data (Array of GraphKit::DataKits): the lines of data to be plotted. 
+
+
+class GraphKit < KitHash
+	
+	
+	include Kit
+	include Log
+	AXES = [:x, :y, :z, :f]
+
+# 	attr_reader :gnuplot_options
+	
+	alias :hash_key :key
+	undef :key
+	
+	# Greate a new graphkit. Rarely used: see GraphKit.autocreate and GraphKit.quick_create
+	
+	def initialize(naxes=0, hash = {})
+		logf :initialize
+		super()
+		self[:naxes] = naxes 
+		self[:data] = []
+		hash
+# 		@gnuplot_options = GnuplotOptions.new
+	end
+	
+# 	def gnuplot_options
+# 		@gnuplot_options ||= GnuplotOptions.new
+# 		@gnuplot_options
+# 	end
+	
+# 	alias :gp :gnuplot_options
+	
+	class DataError < StandardError
+	end
+	
+	# Create a new graphkit with one hash for every datakit (each datakit corresponds to a line or surface on the graph). Each hash should contain specifications for the axes of the graph (see AxisKit#autocreate).
+	#
+	# E.g.
+	# 	kit = GraphKit.autocreate(
+	# 		{
+	# 			x: {data: [1,2,3], title 'x', units: 'm'}, 
+	# 			y: {data: [1,4,9], title 'x^2', units: 'm^2'}
+	# 		}
+	# 	)
+	#
+	# will create a two dimensional graph that plots x^2 against x.
+	
+	def self.autocreate(*hashes)
+		Log.logf :autocreate
+		new(hashes[0].size).autocreate(*hashes)
+	end
+	
+	
+	def lx(*args) # :nodoc:
+		log_axis(*args)
+	end
+	
+	def lx=(val) # :nodoc:  (deprecated)
+		self.log_axis = val
+	end
+	
+	# Create a new graphkit without providing any labels.
+	#
+	# E.g.
+	# 	kit = GraphKit.quick_create(
+	# 		[
+	# 			[1,2,3], 
+	# 			[1,4,9]
+	# 		]
+	# 	)
+	#
+	# will create a two dimensional graph that plots x^2 against x.
+	
+	def self.quick_create(*datasets)
+		hashes = datasets.map do |data|
+			hash = {}
+			data.each_with_index do |dat, i|
+				hash[AXES[i]] = {data: dat}
+			end
+			hash
+		end
+		autocreate(*hashes)
+	end
+	
+	
+	
+	def autocreate(*hashes) # :nodoc:  (see GraphKit.autocreate)
+		logf :autocreate
+		hashes.each{|hash| data.push DataKit.autocreate(hash)}
+# 		pp data
+		[:title, :label, :units, :range].each do |option| 
+			data[0].axes.each do |key, axiskit|
+# 			next unless AXES.include? key
+				self[key + option] = axiskit[option].dup if axiskit[option]
+			end
+		end
+		self.title = data[0].title
+		check_integrity
+		self
+	end
+		
+	# Check that the graphkit conforms to specification; that the data has dimensions that make sense and that the titles and ranges have the right types.
+	
+	def check_integrity
+		logf :check_integrity
+		check(['data.class', Array], ['title.class', [String, NilClass]], ['has_legend.class', [Hash, NilClass]])
+		[[:units, [String, NilClass]], [:range, [Array, NilClass]], [:label, [String, NilClass]], [:title, [String, NilClass]]].each do |prop, klass|
+# 			next unless self[prop]
+			AXES.each do |key|
+# 				p prop, klass
+# 				p instance_eval(prop.to_s + "[#{key.inspect}]"), 'ebb'
+				check(["#{key + prop}.class", klass])
+# 				check(["a key from #{prop}", key, AXES + [:f]])
+			end	
+		end
+		data.each do |datakit|
+			check(['class of a member of the data array', datakit.class, DataKit])
+			check(['datakit.axes.size', datakit.axes.size, naxes])
+			datakit.check_integrity
+		end
+		return true
+	end
+	
+# 	AXES.each do |axisname|
+# 		[:name, :label, :units, :range].each do |option|
+# 			define_method(axisname + option){self[option][axisname]}
+# 			define_method(axisname + option + '='.to_sym){|value| self[option][axisname] = value}
+# 		end
+# 	end
+	
+	@@old_gnuplot_sets = [ :dgrid3d, :title, :style, :term, :terminal, :pointsize, :log_axis, :key, :pm3d, :palette, :view, :cbrange, :contour, :nosurface, :cntrparam, :preamble, :xtics, :ytics]
+	
+	
+# 		@@gnuplot_sets.uniq!
+	
+	# Duplicate the graphkit.
+		
+	def dup
+		logf :dup
+		self.class.new(naxes, self)
+	end
+	
+	# Combine with another graph; titles and labels from the first graph will override the second. 
+
+	def +(other)
+		check(['other.naxes', other.naxes, self.naxes])
+		new = self.class.new(naxes)
+		new.modify(other, [:data])
+		new.modify(self, [:data])
+		new.data = self.data + other.data
+		new
+	end
+	
+	def extend_using(other, mapping = nil)
+		if mapping
+			mapping.each do |mine, others|
+				data[mine].extend_using(other.data[others])
+			end
+		else
+			raise TypeError.new("A graph can only be extended by a graph with the same number of datasets unless a mapping is provided: this graph has #{data.size} and the other graph has #{other.data.size}") unless data.size == other.data.size
+			data.each_with_index do |dataset, index|
+				dataset.extend_using(other.data[index])
+			end
+		end
+	end
+	
+	def each_axiskit(*axes, &block)
+		axes = AXES unless axes.size > 0
+		axes.each do |axis|
+			data.each do |datakit|
+				yield(datakit.axes[axis])
+			end
+		end
+	end
+
+	def plot_area_size
+		logf :plot_area_size
+		shapes = data.map{|datakit| datakit.plot_area_size}.inject do |old,new|
+			for i in 0...old.size
+				old[i][0] = [old[i][0], new[i][0]].min
+				old[i][1] = [old[i][1], new[i][1]].max
+			end
+			old
+		end
+		shapes
+
+	end
+	
+	def transpose!
+		data.each do |datakit|
+			datakit.transpose!
+		end
+		self.xlabel, self.ylabel = ylabel, xlabel
+		self.xrange, self.yrange = xrange, yrange
+	end
+	
+# end #class GraphKit
+
+class DataKit < KitHash
+	
+# 	include  Kit
+	include Log
+	AXES = GraphKit::AXES
+	
+# 	attr_accessor :labels, :ranges, :has_legend, :units, :dimensions
+	
+	def initialize(options = {})
+		super()
+		self[:axes] = {}
+		absorb options
+	end
+
+	def self.autocreate(hash)
+		new.autocreate(hash)
+	end
+	
+	def autocreate(hash)
+		logf :autocreate
+		hash.each do |key, value|
+# 			puts value.inspect
+			if AXES.include? key
+				self[:axes][key] = AxisKit.autocreate(value)
+			else 
+				raise ArgumentError.new("bad key value pair in autocreate: #{key.inspect}, #{value.inspect}")
+			end
+# 			puts self[key].inspect
+		end
+# 		pp self
+		first = true
+		self.title = AXES.map{|axis| axes[axis] ? axes[axis].title : nil}.compact.reverse.inject("") do |str, name|
+			str + name + (first ? (first = false; ' vs ') : ', ')
+		end
+		self.title = self.title.sub(/, $/, '').sub(/ vs $/, '')
+		check_integrity
+		self
+	end
+	
+	def check_integrity
+		logf :check_integrity
+		check(['title.class', [String, NilClass]], ['with.class', [String, NilClass]],  ['axes.class', Hash])
+		axes.keys.each do |key|
+ 			check(["key #{key} from a datakit.axes", key, AXES])
+			check(["self.axes[#{key.inspect}].class", AxisKit])
+			self.axes[key].check_integrity
+		end
+# 		axes.values.map{|axiskit| axiskit.data.to_a.size}.each_with_index do |size, index|
+# 			raise IntegrityError.new("Axis data sets in this datakit have different sizes than the function #{size}, #{f.shape[0]}") unless size == new_size
+# 			size
+# 		end
+# 		puts 'checking f.class', f.class
+# 		check(['f.class', CodeRunner::FunctionKit])
+		
+# 		shape = f.shape
+		log 'checking ranks'
+		allowed_ranks = [[1], [1,1], [1,1,1], [1,1,2], [1,1,1,1], [1,1,2,2], [1,1,1,3]]
+		rnks = ranks
+		log rnks
+		raise IntegrityError.new("The combination of ranks of your data cannot be plotted. Your data has a set of axes with ranks #{rnks.inspect}. (NB, rank 1 corresponds to a vector, rank 2 to a matrix and 3 to a third rank tensor). The only possible sets of types are #{allowed_ranks.inspect}") unless allowed_ranks.include? rnks
+		passed = true
+		case rnks
+		when [1], [1,1], [1,1,1], [1,1,1,1]
+			axes.values.map{|axiskit| axiskit.shape}.inject do |old, new|
+# 				puts old, new
+				passed = false unless new == old
+				old
+			end
+		when [1,1,2], [1,1,2,2]
+# 			passed = false unless axes[:x].shape == axes[:y].shape
+			passed = false unless axes[:z].shape == [axes[:x].shape[0], axes[:y].shape[0]]
+			passed = false unless axes[:z].shape == axes[:f].shape if axes[:f]
+		when [1,1,1,3]
+			axes.values_at(:x, :y, :z).map{|axiskit| axiskit.shape}.inject do |old, new|
+				passed = false unless new == old
+				old
+			end
+			passed = false unless axes[:f].shape == [axes[:x].shape[0], axes[:y].shape[0], axes[:z].shape[0]]
+		end
+		raise IntegrityError.new(%[The dimensions of this data do not match: \n#{axes.inject(""){|str, (axis, axiskit)| str + "#{axis}: #{axiskit.shape}\n"}}\nranks: #{rnks}]) unless passed 
+# 		log 'finished checking ranks'
+		logfc :check_integrity
+# 		raise IntegrityError.new("function data must be a vector, or have the correct dimensions (or shape) for the axes: function dimensions: #{shape}; axes dimesions: #{axes_shape}") unless shape.size == 1 or axes_shape == shape
+		return true
+	end
+	
+	def shapes
+		logf :shapes
+		ans = axes.values_at(*AXES).compact.inject([]){|arr, axis| arr.push axis.shape}
+		logfc :shapes
+		return ans
+	end
+	
+	def ranks
+		logf :ranks
+		ans = shapes.map{|shape| shape.size}
+		logfc :ranks
+		return ans
+	end
+	
+	def extend_using(other)
+		raise "A dataset can only be extended using another dataset with the same ranks: the ranks of this dataset are #{ranks} and the ranks of the other dataset are #{other.ranks}" unless ranks == other.ranks
+		axes.each do |key, axiskit|
+			axiskit.extend_using(other.axes[key])
+		end
+	end
+	
+# 	def gnuplot_ranks
+# 		case axes.size
+# 		when 1,2
+# 			return ranks
+# 		when 3
+# 			return [1,1,2]
+# 		when 4
+# 			case ranks[2]
+# 			when 1
+# 				return [1,1,1,3]
+# 			when 2
+# 				return [1,1,2,2]
+# 			end
+# 		end
+# 	end
+# 	
+# 	def gnuplot
+# # 		p axes.values_at(*AXES).compact.zip(gnuplot_ranks)
+# 		Gnuplot::DataSet.new(axes.values_at(*AXES).compact.zip(gnuplot_ranks).map{|axis, rank|  axis.data_for_gnuplot(rank) }) do |ds|
+# 			(keys - [:axes, :outlier_tolerance, :outliers, :gnuplot_options]).each do |key|
+# 				ds.set(key, self[key])
+# 			end
+# 			if @gnuplot_options
+# 				@gnuplot_options.each do |opt, val|
+# 					ds.set(opt, val)
+# 				end
+# 			end
+# # 			ds.title = title
+# # 			ds.with = [:lines, :points].inject(""){|str, opt| self[opt] ? str + opt.to_s : str }
+# # 			p ds.with
+# 		#	ds.with = "lines"
+# 	# 					ds.linewidth = 4
+# 		end
+# 	end
+# 
+# 	def gnuplot_options
+# 		@gnuplot_options ||= GnuplotPlotOptions.new
+# 		@gnuplot_options
+# 	end
+# 	
+# 	alias :gp :gnuplot_options
+# 
+	
+	AXES.each do |axisname|
+		define_method(axisname + :axis){self[:axes][axisname]}
+		define_method(axisname + :axis + '='.to_sym){|value| self[:axes][axisname] = value}
+	end
+
+	def dup
+# 		puts 'Datakit.dup'
+		new = self.class.new(self)
+		new.axes.each do |axis, value|
+			new.axes[axis] = value.dup
+		end
+		new
+	end
+
+	def plot_area_size
+		ans = []
+# 		p data
+		(axes.values_at(*AXES).compact).each do |axiskit|
+			if range = axiskit.range
+				ans.push range
+				next
+			else
+# 				p 'hello'
+# 				p data[0].axes[key]
+				axdata = axiskit.data #(key == :f) ? data[0].f.data : (next unless data[0].axes[key]; data[0].axes[key].data)
+				next unless axdata
+				ans.push [axdata.min, axdata.max]
+			end
+		end
+		ans
+	end
+
+	def exclude_outliers
+		raise "Can only get rid of outliers for 1D or 2D data" if axes.size > 2
+# 		self.outliers = []
+		if axes.size == 1
+			data = axes[:x].data
+			i = 0
+			loop do 
+				break if i > data.size - 2
+				should_be = (data[i+1] + data[i-1]) / 2.0
+				deviation = (should_be - data[i]).abs / data[i].abs
+				if deviation > outlier_tolerance
+					data.delete_at(i)
+					i-=1
+				end
+				i+=1
+			end
+		else
+			x_data = axes[:x].data
+			data = axes[:y].data
+			i = 0
+			loop do 
+				jump = 1
+				loop do 
+					break if i > data.size - 1 - jump
+					break unless x_data[i+jump] == x_data[i-jump]
+					jump += 1
+				end
+				break if i > data.size - 1 - jump
+				should_be = data[i-jump] + (data[i+jump] - data[i-jump]) / (x_data[i+jump] - x_data[i-jump]) * (x_data[i] - x_data[i-jump]) #ie y1 + gradient * delta x
+				deviation = (should_be - data[i]).abs / data[i].abs
+				if deviation > outlier_tolerance
+					data.delete_at(i)
+					x_data.delete_at(i)
+					i-=1
+				end
+				i+=1
+			end
+		end
+# 		p self.outliers
+	end
+	
+# 	def exclude_outliers
+# 		raise "Can only get rid of outliers for 1D or 2D data" if axes.size > 2
+# # 		self.outliers = []
+# 		if axes.size == 1
+# 			outliers.sort.reverse_each do |index|
+# 				axes[:x].data.delete_at(index)
+# 			end
+# 		else
+# 			outliers.sort.reverse_each do |index|
+# 				axes[:x].data.delete_at(index)
+# 				axes[:y].data.delete_at(index)
+# 			end
+# 
+# 		end
+# 		check_integrity
+# 	end
+
+		
+	
+end
+
+
+class AxisKit < KitHash
+	
+# 	include  Kit
+	include Log
+		AXES = GraphKit::AXES
+
+	
+# 	attr_accessor :labels, :ranges, :has_legend, :units, :dimensions
+	
+	def initialize(hash = {})
+		super()
+		self.title = ""
+		self.units = ""
+		self.
+		absorb hash
+	end
+	
+	def check_integrity
+		check(['units.class', [String]], ['scaling.class', [Float, NilClass]], ['label.class', [String, NilClass]], ['title.class', [String]])
+		check(['data.to_a.class', Array])
+	end
+	
+	def dup
+# 		puts 'i was called'
+		new = self.class.new(self)
+		new.data = data.dup
+		new
+	end
+	
+	def self.autocreate(hash)
+		new_kit = new(hash)
+		new_kit.label = "#{new_kit.title} (#{new_kit.units})"
+		new_kit
+	end
+	
+	def shape
+		logf :shape
+		if data.methods.include? :shape
+			ans = data.shape
+		elsif data.methods.include? :size
+			ans = [data.size]
+		elsif data.methods.include? :dimensions
+			ans = data.dimensions
+		else
+			raise 'data does not implement size or shape or dimensions methods'
+		end
+		logfc :shape
+		return ans
+	end
+# 	def data_for_gnuplot(rank)
+# 		case rank
+# 		when 0, 1
+# 			return data
+# 		when Fixnum
+# 			if shape.size == 1
+# 				return SparseTensor.diagonal(rank, data)
+# 			else
+# 				return data
+# 			end
+# 		else
+# 			raise TypeError("Bad Rank")
+# 		end
+# 	end
+		
+	def extend_using(other)
+		raise TypeError.new("Can only extend axes if data have the same ranks: #{shape.size}, #{other.shape.size}") unless shape.size == other.shape.size
+		raise TypeError.new("Can only extend axes if data have the same class") unless data.class == other.data.class
+		case shape.size
+		when 1
+			desired_length = shape[0] + other.shape[0]
+			if data.methods.include? :connect
+				self.data = data.connect(other.data)
+			elsif data.methods.include? "+".to_sym
+				data += other
+			else
+				raise TypeError("Extending this type of data is currently not implemented.")
+			end
+			raise "Something went wrong: the length of the extended data #{shape[0]} is not the sum of the lengths of the two original pieces of data #{desired_length}." unless shape[0] == desired_length
+		else
+			raise TypeError("Extending data with this rank: #{shape.size} is currently not implemented.")
+		end
+	end
+				
+end
+
+end # class GraphKit
+
+# end #class CodeRunner
+
+
+if $0 == __FILE__
+
+	a = GraphKit.autocreate({x: {data: [1,3,5,6], units: 'feet', title: 'Height'}})
+	a.gnuplot
+	gets
+	a.close
+	a = CodeRunner::GraphKit.autocreate({x: {data: [2, 5, 11, 22], units: 'years', title: 'Age'}, y: {data: [1,3,5,6], units: 'feet', title: 'Height'}})
+	
+	puts a.pretty_inspect
+	
+	p a.title
+	p a.label
+	p a.chox
+	p a.xlabel
+	p a.yunits
+	
+# 	a.gnuplot
+# 	gets
+# 	a.close 
+	a.data[0].with = 'lp'
+	datakit = a.data[0].dup
+	datakit.axes[:y].data.map!{|value| value * 0.85}
+	datakit.title += ' of women'
+	a.data.push datakit
+	a.data[0].title += ' of men'
+	pp a
+	a.gnuplot
+	gets
+	a.close
+# 	Gnuplot.open{a.to_gnuplot}
+	
+	b = CodeRunner::GraphKit.autocreate({x: {data: [2, 5, 11, 22], units: 'years', title: 'Age'}, y: {data: [1,3,5,6], units: 'feet', title: 'Height'}, z: {data: [2,4,8,12], units: 'stone', title: 'Weight'}})
+	b.data[0].modify({with: 'lp'})
+	pp b
+# 	d = b.data[0].f.data_for_gnuplot(2)
+# 	p d
+# 	p d[0,1]
+# 	d.delete([0,0])
+# 	p d
+# 	p d[1,1]
+# 	p d[1,2]
+# 	d = SparseTensor.new(3)
+# 	p d
+# 	p d[0,1,4]
+# 	p d[3, 4,6]
+# 
+	b.gnuplot	
+	gets
+	b.close
+	b.gnuplot_write('heights.ps')
+	
+	p b.data[0].plot_area_size
+	
+	c = SparseTensor.new(3)
+	c[1,3,9]= 4
+	c[3,3,34] = 4.346
+	c[23, 234, 293] = 9.234
+	
+	p c
+	
+	d = SparseTensor.new(3)
+	d[1,3,9]= 4
+	d[3,3,34] = 4.346
+	d[23, 234, 294] = 9.234
+	
+	p c + d
+
+end
+
+	
+# A graph kit is 'everything you need..
+#A graph kit is, in fact, a very intelligent hash

data/lib/graphkit/gnuplot.rb

@@ -0,0 +1,412 @@
+
+class GraphKit
+
+class GnuplotSetOptions < KitHash
+	alias :hash_key :key
+	undef :key
+	GNUPLOT_SETS = %w[    
+		angles            arrow             autoscale         bars
+    bmargin           border            boxwidth          cbdata
+    cbdtics           cblabel           cbmtics           cbrange
+    cbtics            clabel            clip              cntrparam
+    colorbox          contour           data              datafile 
+    date_specifiers   decimalsign       dgrid3d           dummy    
+    encoding          fit               fontpath          format
+    function          grid              hidden3d          historysize
+    isosamples        key               label             lmargin
+    loadpath          locale            log               logscale
+    macros            mapping           margin            missing
+    mouse             multiplot         mx2tics           mxtics
+    my2tics           mytics            mztics            object
+    offsets           origin            output            palette
+    parametric        pm3d              pointsize         polar
+    print             rmargin           rrange            samples
+    size              style             surface           table
+    term              terminal          termoption        tics
+    ticscale          ticslevel         time_specifiers   timefmt
+    timestamp         title             tmargin           trange
+    urange            view              vrange            x2data
+    x2dtics           x2label           x2mtics           x2range
+    x2tics            x2zeroaxis        xdata             xdtics
+    xlabel            xmtics            xrange            xtics
+    xyplane           xzeroaxis         y2data            y2dtics
+    y2label           y2mtics           y2range           y2tics
+    y2zeroaxis        ydata             ydtics            ylabel
+    ymtics            yrange            ytics             yzeroaxis
+    zdata             zdtics            zero              zeroaxis
+    zlabel            zmtics            zrange            ztics].map{|s| s.to_sym}
+# 		p instance_methods.sort
+		GNUPLOT_SETS.each do |opt|
+			define_method(opt + "=".to_sym) do |str|
+				check(["Class of #{str} supplied to #{opt}", str.class, [Array, String, FalseClass, NilClass]])
+				self[opt] = str
+			end
+			define_method(opt) do
+				self[opt]
+			end
+		end
+			
+		
+		def []=(opt, val)
+			raise "#{opt} is not a valid gnuplot set option" unless GNUPLOT_SETS.include? opt
+			super
+		end
+end
+
+class GnuplotPlotOptions < KitHash
+	alias :hash_key :key
+	undef :key
+	GNUPLOT_SETS = %w[    
+		acsplines         axes              bezier            binary
+    csplines          cumulative        datafile          errorbars
+    errorlines        every             example           frequency
+    index             iteration         kdensity          matrix
+    parametric        ranges            sbezier           smooth
+    special-filenames style             thru              title
+    unique            using             with].map{|s| s.to_sym}
+# 		p instance_methods.sort
+		GNUPLOT_SETS.each do |opt|
+			define_method(opt + "=".to_sym) do |str|
+				check(["Class of #{str} supplied to #{opt}", str.class, [Array, String, FalseClass, NilClass]])
+				self[opt] = str
+			end
+			define_method(opt) do
+				self[opt]
+			end
+		end
+			
+		
+		def []=(opt, val)
+			raise "#{opt} is not a valid gnuplot set option" unless GNUPLOT_SETS.include? opt
+			super
+		end
+end
+
+# class GraphKit < KitHash
+	
+	def gnuplot_options
+		@gnuplot_options ||= GnuplotSetOptions.new
+		@gnuplot_options
+	end
+	
+	alias :gp :gnuplot_options
+
+	@@old_gnuplot_sets = [:output, :dgrid3d, :title, :style, :term, :terminal, :pointsize, :log_axis, :key, :pm3d, :palette, :view, :cbrange, :contour, :nosurface, :cntrparam, :preamble, :xtics, :ytics]
+	
+	
+# 		@@gnuplot_sets.uniq!
+	
+	def gnuplot(options = {})
+		logf :gnuplot
+		processes = %x[ps | grep 'gnuplot'].scan(/^\s*\d+/).map{|match| match.to_i}
+		if options[:outlier_tolerance]
+			raise "Can only get rid of outliers for 1D or 2D data" if naxes > 2
+			data.each do |datakit|
+				datakit.outlier_tolerance = options[:outlier_tolerance]
+# 				datakit.calculate_outliers
+				datakit.exclude_outliers
+			end
+			options.delete(:outlier_tolerance)
+		end
+		live = options[:live]
+		options.delete(:live) if live
+		check_integrity
+		if (self.view =~ /map/ or self.pm3d =~ /map/) and naxes < 4
+			self.cbrange ||= self.zrange
+			options[:cbrange] ||= options[:zrange] if options[:zrange]
+		end
+		options.each   do |k,v|
+# 						ep option, val if option == :xrange
+
+					# 					ep k, v
+					set(k, v)
+		end
+
+		
+		Gnuplot.open do |gp|
+			log 'opened gnuplot'
+			plotproc  = Proc.new do |plot|
+				log 'creating plotproc'
+				[:label, :range].each do |property|
+
+					(AXES - [:f]).each do |axis|
+						option = axis + property
+						val = self.send(option)		
+# 						ep option, val if option == :xrange
+						if val
+						
+						if property == :range
+							val = "[#{val[0]}:#{val[1]}]"
+						end
+						plot.send(option, val)
+						end
+					end
+				end
+				
+				
+				
+				@@old_gnuplot_sets.each do |option|
+# 					p option
+					next unless val = send(option) # single = deliberate
+					val = "[#{val[0]}:#{val[1]}]" if option == :cbrange
+					plot.send(option, val)
+				end
+				
+				#Should change this to keys
+				
+				GnuplotSetOptions::GNUPLOT_SETS.each do |option|
+# 					p option
+					next unless val = gnuplot_options.send(option) # single = deliberate
+					val = "[#{val[0]}:#{val[1]}]" if option == :cbrange
+					plot.send(option, val)
+				end
+				
+# 				plot.ylabel ylabel
+# 				plot.xlabel xlabel
+				data.each do |datakit|
+					plot.data << datakit.gnuplot 
+				end
+				log 'created plotproc'
+				
+			end
+			log 'sending plotproc'
+			case naxes
+			when 1,2
+# 				puts '2 naxes'
+				Gnuplot::Plot.new(gp){|plot| plotproc.call(plot)}
+			when 3,4
+				Gnuplot::SPlot.new(gp){|plot| plotproc.call(plot)}
+			else
+				raise IntegrityError.new("This number of axes: #{axes} is not supported")
+			end
+			log 'sent plotproc'
+			(STDIN.gets) if live
+
+		end
+		self.pid = (%x[ps | grep 'gnuplot'].scan(/^\s*\d+/).map{|match| match.to_i} - processes)[-1]
+# 		p pid
+	end
+	
+	
+	def gnuplot_write(file_name, options={})
+		logf :gnuplot_write
+		if file_name
+			options[:output] = file_name
+			unless options[:term] or options[:terminal]
+				case File.extname(file_name)
+				when '.pdf'
+					options[:term] = 'pdf size 20cm,15cm'
+				when '.ps'
+					options[:term] = 'post color'
+				when '.eps'
+					unless options[:latex]
+						options[:term] = %[post eps color enhanced size  #{options[:size] or "3.5in,2.33in"}]
+					else
+						options[:term] ||= "epslatex color dashed size #{options[:size] or "3.5in,#{options[:height] or "2.0in"}"} colortext standalone 8"
+						options[:output] = file_name.sub(/\.eps/, '.tex')
+					end
+				when '.jpg'
+					options[:term] = "jpeg size  #{options[:size] or "3.5in,2.33in"}"
+				when '.png'
+					options[:term] = "png size  #{options[:size] or "10in,7.5in"}"
+				
+				end
+			end
+		end
+		options.delete(:size)
+		gnuplot(options)
+		if options[:latex]
+				name = file_name.sub(/\.eps$/, '')
+				raise 'latex failed' unless system "latex #{name}.tex"
+				raise 'dvips failed' unless system "dvips #{name}.dvi"
+				FileUtils.rm "#{name}.eps" if FileTest.exist? "#{name}.eps"
+				raise 'ps2eps failed' unless system "ps2eps #{name}.ps"
+		end
+# 		ep file_name
+		return File.basename(file_name, File.extname(file_name))
+	end
+	
+	def self.latex_multiplot(name, options={})
+		name = name.sub(/\.eps$/, '')
+		figure_preamble = options[:preamble] || <<EOF
+\\documentclass[prl,graphicx,reprint,twocolumn, superscriptaddress]{revtex4}
+%\documentclass[aip,reprint]{revtex4-1}
+\\usepackage{graphics,bm,overpic,subfigure,color}
+
+\\pagestyle{empty}
+\\begin{document}
+\\begin{figure}
+EOF
+
+		figure_postamble = options[:postamble] || <<EOF
+\\end{figure}
+\\end{document}
+EOF
+		text = <<EOF
+#{figure_preamble}
+#{yield}
+#{figure_postamble}
+EOF
+			File.open("#{name}.tex", 'w'){|f| f.puts text}
+		raise 'latex failed'  unless system "latex #{name}.tex"
+		raise 'dvips failed' unless system "dvips #{name}.dvi"
+		FileUtils.rm "#{name}.eps" if FileTest.exist? "#{name}.eps"
+		raise 'ps2eps failed' unless system "ps2eps #{name}.ps"
+	end
+
+	def close
+		logf :close
+		begin
+			Process.kill('TERM', pid) if pid
+		rescue => err
+			puts err
+		end
+		self.pid = nil
+	end
+
+		
+	
+# end
+
+class DataKit < KitHash
+	
+
+	def gnuplot_ranks
+		case axes.size
+		when 1,2
+			return ranks
+		when 3
+			return [1,1,2]
+		when 4
+			case ranks[2]
+			when 1
+				return [1,1,1,3]
+			when 2
+				return [1,1,2,2]
+			end
+		end
+	end
+	
+	def gnuplot
+# 		p axes.values_at(*AXES).compact.zip(gnuplot_ranks)
+		Gnuplot::DataSet.new(axes.values_at(*AXES).compact.zip(gnuplot_ranks).map{|axis, rank|  axis.data_for_gnuplot(rank) }) do |ds|
+			(keys - [:axes, :outlier_tolerance, :outliers, :gnuplot_options]).each do |key|
+				ds.set(key, self[key])
+			end
+			if @gnuplot_options
+				@gnuplot_options.each do |opt, val|
+					ds.set(opt, val)
+				end
+			end
+# 			ds.title = title
+# 			ds.with = [:lines, :points].inject(""){|str, opt| self[opt] ? str + opt.to_s : str }
+# 			p ds.with
+		#	ds.with = "lines"
+	# 					ds.linewidth = 4
+		end
+	end
+
+	def gnuplot_options
+		@gnuplot_options ||= GnuplotPlotOptions.new
+		@gnuplot_options
+	end
+	
+	alias :gp :gnuplot_options
+
+	
+end
+
+
+class AxisKit < KitHash
+	
+
+	def data_for_gnuplot(rank)
+		case rank
+		when 0, 1
+			return data
+		when Fixnum
+			if shape.size == 1
+				return SparseTensor.diagonal(rank, data)
+			else
+				return data
+			end
+		else
+			raise TypeError("Bad Rank")
+		end
+	end
+		
+end
+
+end # class GraphKit
+# end #class CodeRunner
+
+
+if $0 == __FILE__
+
+	a = CodeRunner::GraphKit.autocreate({x: {data: [1,3,5,6], units: 'feet', title: 'Height'}})
+	a.gnuplot
+	gets
+	a.close
+	a = CodeRunner::GraphKit.autocreate({x: {data: [2, 5, 11, 22], units: 'years', title: 'Age'}, y: {data: [1,3,5,6], units: 'feet', title: 'Height'}})
+	
+	puts a.pretty_inspect
+	
+	p a.title
+	p a.label
+	p a.chox
+	p a.xlabel
+	p a.yunits
+	
+# 	a.gnuplot
+# 	gets
+# 	a.close 
+	a.data[0].with = 'lp'
+	datakit = a.data[0].dup
+	datakit.axes[:y].data.map!{|value| value * 0.85}
+	datakit.title += ' of women'
+	a.data.push datakit
+	a.data[0].title += ' of men'
+	pp a
+	a.gnuplot
+	gets
+	a.close
+# 	Gnuplot.open{a.to_gnuplot}
+	
+	b = CodeRunner::GraphKit.autocreate({x: {data: [2, 5, 11, 22], units: 'years', title: 'Age'}, y: {data: [1,3,5,6], units: 'feet', title: 'Height'}, z: {data: [2,4,8,12], units: 'stone', title: 'Weight'}})
+	b.data[0].modify({with: 'lp'})
+	pp b
+# 	d = b.data[0].f.data_for_gnuplot(2)
+# 	p d
+# 	p d[0,1]
+# 	d.delete([0,0])
+# 	p d
+# 	p d[1,1]
+# 	p d[1,2]
+# 	d = SparseTensor.new(3)
+# 	p d
+# 	p d[0,1,4]
+# 	p d[3, 4,6]
+# 
+	b.gnuplot	
+	gets
+	b.close
+	b.gnuplot_write('heights.ps')
+	
+	p b.data[0].plot_area_size
+	
+	c = SparseTensor.new(3)
+	c[1,3,9]= 4
+	c[3,3,34] = 4.346
+	c[23, 234, 293] = 9.234
+	
+	p c
+	
+	d = SparseTensor.new(3)
+	d[1,3,9]= 4
+	d[3,3,34] = 4.346
+	d[23, 234, 294] = 9.234
+	
+	p c + d
+
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+name: graphkit
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Edmund Highcock
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-26 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: A GraphKit is a device independent intelligent data container that allows the easy sharing, combining and plotting of graphic data representations. Easily created from data, they can be output in a variety of formats using packages such as gnuplot
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/graphkit.rb
+- lib/graphkit/gnuplot.rb
+has_rdoc: true
+homepage: http://graphkit.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: graphkit
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Graph object with intuitive combining and plotting functions.
+test_files: []
+