opr-calc 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 434b7eba4789fd454564da8db982a45cbc31c5ce
-  data.tar.gz: 71bbf74562b830a636202be0c0e100785c125b6a
+  metadata.gz: bc4b64c17002cc19c3c9ccda154fdeecd1a57043
+  data.tar.gz: e1aa8b1a9fd828b2d3a76fce85f3c0a7d961b2cb
 SHA512:
-  metadata.gz: bc786e92a7d323d21ab2cacd40b7a05379453215b238754d45d2a490f17bb9473c1ea9067ad0d9140432c4c4e2737d600c55e3f96b78380ba7abe0a6939f6ab1
-  data.tar.gz: 58a190ddaf8aa3b405b5e80127f66a28f1682f3df4cc907d7976bb9f05c9b1252e50b752538f61dab2a00e6a54a66fab70d676358de3a6c5a6e0da8c6b0ed133
+  metadata.gz: d1d6b5e73181e786af4e61bfa0c8f4976c0aa371daded216bd2306de6c2847984d01da721c4f82bad26c5a0995044c2c20bcc09306d7e65ec28305f5a0b0a2fb
+  data.tar.gz: a76ab942d81c005e258c71e7a0eb3e71fbee67836c430c055da23a724b63ece9e7faf7bd22e8c003ed67d9c7dd014982946f4591c3f275182b26a86f4acfe279

data/lib/opr-calc.rb

@@ -1,325 +1,20 @@
-#!/usr/bin/env ruby
-
 =begin
-    opr-calc is a tool for calculating OPR and other scouting stats for FRC teams.
-    Copyright (C) 2014 Kristofer Rye and Christopher Cooper
+	opr-calc is a tool for calculating OPR and other scouting stats for FRC teams.
+	Copyright (C) 2014 Kristofer Rye and Christopher Cooper
 
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-require 'matrix'
-
-# Props to http://rosettacode.org/wiki/Cholesky_decomposition#Ruby :L
-class Matrix
-	# Returns whether or not the Matrix is symmetric (http://en.wikipedia.org/wiki/Symmetric_matrix)
-	def symmetric?
-
-		# Matrices can't be symmetric if they're not square.
-		return false if not square?
-
-		(0...row_size).each do |i|
-			(0..i).each do |j|
-				return false if self[i,j] != self[j,i]
-			end
-		end
-
-		true
-	end
-
-	def cholesky_factor
-		# We need a symmetric matrix for Cholesky.
-		raise ArgumentError, "You must provide symmetric matrix" unless symmetric?
-
-		# Make a new matrix to return
-		l = Array.new(row_size) { Array.new(row_size, 0) }
-
-		(0...row_size).each do |k|
-			(0...row_size).each do |i|
-				if i == k
-					sum = (0..k-1).inject(0.0) {|sum, j| sum + l[k][j] ** 2}
-					val = Math.sqrt(self[k,k] - sum)
-					l[k][k] = val
-				elsif i > k
-					sum = (0..k-1).inject(0.0) {|sum, j| sum + l[i][j] * l[k][j]}
-					val = (self[k,i] - sum) / l[k][k]
-					l[i][k] = val
-				end
-			end
-		end
-
-		Matrix[*l]
-	end
-
-	# A helpful debug function for Matrices
-	def output
-		(0..self.row_size - 1).each do |row_number|
-			(0..self.column_size - 1).each do |column_number|
-				printf("%8.4f ", self[row_number, column_number])
-			end
-			printf("\n")
-		end
-		self
-	end
-end
-
-
-
-class ScoreSet
-	attr_reader :ared, :ablue, :scorered, :scoreblue
-
-	def ared=(value)
-		@ared = value
-		@opr_recalc = @dpr_recalc = @ccwm_recalc = true
-	end
-	def ablue=(value)
-		@ablue = value
-		@opr_recalc = @dpr_recalc = @ccwm_recalc = true
-	end
-	def scorered=(value)
-		@scorered = value
-		@opr_recalc = @dpr_recalc = @ccwm_recalc = true
-	end
-	def scoreblue=(value)
-		@scoreblue = value
-		@opr_recalc = @dpr_recalc = @ccwm_recalc = true
-	end
-
-	def initialize(ared, ablue, scorered, scoreblue)
-		@ared = ared
-		@ablue = ablue
-		@scorered = scorered
-		@scoreblue = scoreblue
-	end
-
-	# A generic function for smooshing two matrices (one red, one blue).
-	# Each should have the same dimensions.
-	def alliance_smooshey(redmatrix, bluematrix)
-		throw ArgumentError "Matrices must have same dimensions" unless (redmatrix.row_size == bluematrix.row_size) && (redmatrix.column_size == bluematrix.column_size)
-
-		# Then we just pull the column and row size from the red matrix because we can.
-		column_count = redmatrix.column_size
-		row_count = redmatrix.row_size
-
-		# Use a block function to generate the new matrix
-		matrix = Matrix.build(row_count * 2, column_count) do
-			|row, column|
-
-			# note: no need to alternate, instead put all red, then all blue
-			if row < row_count 	# first half = red
-				redmatrix[row, column]
-			else 				# second half = blue
-				bluematrix[row - row_count, column]
-			end
-		end
-		# This will end up looking like as follows:
-
-		# [[red[0]],
-		#  [red[1]],
-		#  [red[2]],
-		#  ...
-		#  [red[n]],
-		#  [blue[0]],
-		#  [blue[1]],
-		#  [blue[2]],
-		#  ...
-		#  [blue[n]]]
-		return matrix
-	end
-
-	private :alliance_smooshey
-
-	# Solve equation of form [l][x] = [s] for [x]
-	# l must be a lower triangular matrix.
-	# Based off of algorithm given at http://en.wikipedia.org/wiki/Triangular_matrix#Forward_and_back_substitution
-	def forward_substitute(l, s)
-		raise "l must be a lower triangular matrix" unless l.lower_triangular?
-
-		x = Array.new s.row_size
-
-		x.size.times do |i|
-			x[i] = s[i, 0]
-			i.times do |j|
-				x[i] -= l[i, j] * x[j]
-			end
-			x[i] /= l[i, i]
-		end
-
-		Matrix.column_vector x
-	end
-
-	# Solve equation of form [u][x] = [s] for [x]
-	# u must be a upper triangular matrix.
-	def back_substitute(u, s)
-		raise "u must be an upper triangular matrix" unless u.upper_triangular?
-
-		x = Array.new s.row_size
-
-		(x.size - 1).downto 0 do |i|
-			x[i] = s[i, 0]
-			(i + 1).upto(x.size - 1) do |j|
-				x[i] -= u[i, j] * x[j]
-			end
-			x[i] /= u[i, i]
-		end
-
-		Matrix.column_vector x
-	end
-
-	private :forward_substitute, :back_substitute
-
-=begin
- base matrix equation: [A][OPR] = [SCORE]
- define [A]^t to be [A] transpose
- define [P] to be [A]^t[A]
- define [S] to be [A]^t[SCORE]
- equation is now [P][OPR] = [S]
- refactor [P] as [L][L]^t using cholesky
- [L] is a lower triangular matrix and [L]^t an upper
- Therefore [L][L]^t[OPR] = [S]
- define [Y] = [L]^t[OPR]
- equation is now [L][Y] = [S]
- find [Y] through forward substitution
- find [OPR] through back substitution
-=end
-
-	def opr_calculate(a, score)
-		p = a.t * a
-		s = a.t * score
-
-		l = p.cholesky_factor
-
-		# l.output
-		# l.t.output
-
-		y = forward_substitute l, s
-		back_substitute l.t, y
-	end
-
-	# Offensive power rating: the average amount of points that a team contributes to their alliance's score
-	# This is high for a good team
-	def opr(recalc = false)
-		if !@opr || recalc || @opr_recalc
-			a = alliance_smooshey @ared, @ablue
-			score = alliance_smooshey @scorered, @scoreblue
-			
-			@opr = opr_calculate a, score
-			@opr_recalc = false
-		end
-		@opr
-	end
-
-	# Defensive power rating: the average amount of points that a team lets the other alliance score
-	# This is low for a good team
-	def dpr(recalc = false)
-		if !@dpr || recalc || @dpr_recalc
-			a = alliance_smooshey @ared, @ablue
-			score = alliance_smooshey @scoreblue, @scorered # intentionally swapped, that's how dpr works
-			
-			@dpr = opr_calculate a, score
-			@dpr_recalc = false
-		end
-		@dpr
-	end
-
-	# Calculated contribution to winning margin: the average amount of points that a team contributes to their alliance's winning margin
-	# This is high for a good team
-	def ccwm(recalc = false)
-		if !@ccwm || recalc || @ccwm_recalc
-			a = alliance_smooshey @ared, @ablue
-			
-			red_wm = Matrix.build(@scorered.row_size, @scorered.column_size) do |row, column|
-				@scorered[row, column] - @scoreblue[row, column]
-			end
-			blue_wm = Matrix.build(@scoreblue.row_size, @scoreblue.column_size) do |row, column|
-				@scoreblue[row, column] - @scorered[row, column]
-			end
-
-			score = alliance_smooshey red_wm, blue_wm
-
-			@ccwm = opr_calculate a, score
-			@ccwm_recalc = false
-		end
-		@ccwm
-	end
-
-end
-
-
-def test_stuff
-	# Team 0 opr: 0
-	# Team 1 opr: 1
-	# Team 2 opr: 2
-	# ...
-
-	# I don't think any team is every playing on both blue and red at the same time, but I might be wrong
-
-	#                   0  1  2  3  4  5  6  7  8  9
-	test_ared = Matrix[[1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-	                   [0, 1, 0, 1, 0, 1, 0, 0, 0, 0],
-	                   [0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
-	                   [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
-	                   [0, 1, 0, 0, 0, 1, 1, 0, 0, 0],
-	                   [1, 0, 0, 1, 0, 0, 1, 0, 0, 0]]
-
-	#                    0  1  2  3  4  5  6  7  8  9
-	test_ablue = Matrix[[0, 0, 1, 0, 0, 0, 0, 1, 0, 1],
-	                    [1, 0, 0, 0, 1, 0, 0, 0, 1, 0],
-	                    [1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
-	                    [0, 0, 1, 0, 0, 1, 1, 0, 0, 0],
-	                    [0, 0, 0, 1, 0, 0, 0, 0, 1, 1],
-	                    [0, 1, 0, 0, 1, 0, 0, 1, 0, 0]]
-
-
-	test_scorered = Matrix[[6],
-	                       [9],
-	                       [15],
-	                       [24],
-	                       [12],
-	                       [9]]
-
-	test_scoreblue = Matrix[[18],
-	                        [12],
-	                        [3],
-	                        [13],
-	                        [20],
-	                        [12]]
-
-	test_expectedopr = Matrix[[0],
-	                          [1],
-	                          [2],
-	                          [3],
-	                          [4],
-	                          [5],
-	                          [6],
-	                          [7],
-	                          [8],
-	                          [9]]
-
-	test = ScoreSet.new test_ared, test_ablue, test_scorered, test_scoreblue
-
-	puts "Expected OPR:"
-	test_expectedopr.output
-	puts "Actual OPR:"
-	test.opr.output
-	
-	puts "DPR:"
-	test.dpr.output
-	
-	puts "CCWM:"
-	test.ccwm.output
-	puts "CCWM by OPR - DPR:"
-	(test.opr - test.dpr).output
-
-	return true
-end
+require "opr-calc/matrix.rb"
+require "opr-calc/score_set.rb"

data/lib/opr-calc/matrix.rb

@@ -0,0 +1,75 @@
+=begin
+	opr-calc is a tool for calculating OPR and other scouting stats for FRC teams.
+	Copyright (C) 2014 Kristofer Rye and Christopher Cooper
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require "matrix"
+
+# Props to http://rosettacode.org/wiki/Cholesky_decomposition#Ruby :L
+class Matrix
+	# Returns whether or not the Matrix is symmetric (http://en.wikipedia.org/wiki/Symmetric_matrix).
+	def symmetric?
+		# Matrices can't be symmetric if they're not square.
+		return false unless square?
+
+		(0...row_size).each do |i|
+			(0..i).each do |j|
+				return false if self[i,j] != self[j,i]
+			end
+		end
+
+		true
+	end
+
+	# Determines the [L] matrix through Cholesky decomposition.
+	# To obtain [L]*, just transpose the matrix, it should work.
+	def cholesky_factor
+		# We need a symmetric matrix for Cholesky decomposition.
+		raise ArgumentError, "must provide a symmetric matrix" unless symmetric?
+
+		# Make a new matrix to return.
+		l = Array.new(row_size) { Array.new(row_size, 0) }
+
+		(0...row_size).each do |k|
+			(0...row_size).each do |i|
+				if i == k
+					sum = (0..k-1).inject(0.0) { |sum, j| sum + l[k][j] ** 2 }
+					val = Math.sqrt(self[k,k] - sum)
+					l[k][k] = val
+				elsif i > k
+					sum = (0..k-1).inject(0.0) { |sum, j| sum + l[i][j] * l[k][j] }
+					val = (self[k,i] - sum) / l[k][k]
+					l[i][k] = val
+				end
+			end
+		end
+
+		Matrix[*l]
+	end
+
+	# A helpful debug function for Matrices.
+	def output
+		(0..self.row_size - 1).each do |row_number|
+			(0..self.column_size - 1).each do |column_number|
+				printf("%8.4f ", self[row_number, column_number])
+			end
+
+			printf("\n")
+		end
+
+		self
+	end
+end

data/lib/opr-calc/score_set.rb

@@ -0,0 +1,213 @@
+=begin
+	opr-calc is a tool for calculating OPR and other scouting stats for FRC teams.
+	Copyright (C) 2014 Kristofer Rye and Christopher Cooper
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+module OPRCalc
+	class ScoreSet
+		attr_reader :ared, :ablue, :scorered, :scoreblue
+
+		def ared=(value)
+			@ared = value
+			@opr_recalc = @dpr_recalc = @ccwm_recalc = true
+		end
+		
+		def ablue=(value)
+			@ablue = value
+			@opr_recalc = @dpr_recalc = @ccwm_recalc = true
+		end
+		
+		def scorered=(value)
+			@scorered = value
+			@opr_recalc = @dpr_recalc = @ccwm_recalc = true
+		end
+		
+		def scoreblue=(value)
+			@scoreblue = value
+			@opr_recalc = @dpr_recalc = @ccwm_recalc = true
+		end
+
+		def initialize(ared, ablue, scorered, scoreblue)
+			raise TypeError, "ared must be a Matrix" unless ared.is_a? Matrix
+			raise TypeError, "ablue must be a Matrix" unless ablue.is_a? Matrix
+			raise TypeError, "scorered must be a Matrix" unless scorered.is_a? Matrix
+			raise TypeError, "scoreblue must be a Matrix" unless scoreblue.is_a? Matrix
+			
+			@ared = ared
+			@ablue = ablue
+			@scorered = scorered
+			@scoreblue = scoreblue
+		end
+
+		# A generic function for smooshing two matrices (one red, one blue).
+		# Each should have the same dimensions.
+		def alliance_smooshey(redmatrix, bluematrix)
+			throw ArgumentError "Matrices must have same dimensions" unless (redmatrix.row_size == bluematrix.row_size) && (redmatrix.column_size == bluematrix.column_size)
+
+			# Then we just pull the column and row size from the red matrix because we can.
+			column_count = redmatrix.column_size
+			row_count = redmatrix.row_size
+
+			# Use a block function to generate the new matrix.
+			matrix = Matrix.build(row_count * 2, column_count) do
+				|row, column|
+
+				# note: no need to alternate, instead put all red, then all blue.
+				if row < row_count 	# first half = red
+					redmatrix[row, column]
+				else                # second half = blue
+					bluematrix[row - row_count, column]
+				end
+			end
+			
+			# This will end up looking like as follows:
+
+			# [[red[0]],
+			#  [red[1]],
+			#  [red[2]],
+			#  ...
+			#  [red[n]],
+			#  [blue[0]],
+			#  [blue[1]],
+			#  [blue[2]],
+			#  ...
+			#  [blue[n]]]
+			return matrix
+		end
+
+		private :alliance_smooshey
+
+		# Solve equation of form [l][x] = [s] for [x]
+		# l must be a lower triangular matrix.
+		# Based off of algorithm given at `http://en.wikipedia.org/wiki/Triangular_matrix#Forward_and_back_substitution`.
+		def forward_substitute(l, s)
+			raise "l must be a lower triangular matrix" unless l.lower_triangular?
+
+			x = Array.new s.row_size
+
+			x.size.times do |i|
+				x[i] = s[i, 0]
+				
+				i.times do |j|
+					x[i] -= l[i, j] * x[j]
+				end
+				
+				x[i] /= l[i, i]
+			end
+
+			Matrix.column_vector x
+		end
+
+		# Solve equation of form [u][x] = [s] for [x]
+		# u must be a upper triangular matrix.
+		def back_substitute(u, s)
+			raise "u must be an upper triangular matrix" unless u.upper_triangular?
+
+			x = Array.new s.row_size
+
+			(x.size - 1).downto 0 do |i|
+				x[i] = s[i, 0]
+				
+				(i + 1).upto(x.size - 1) do |j|
+					x[i] -= u[i, j] * x[j]
+				end
+				
+				x[i] /= u[i, i]
+			end
+
+			Matrix.column_vector x
+		end
+
+		private :forward_substitute, :back_substitute
+		
+		# base matrix equation: [A][OPR] = [SCORE]
+		# define [A]^t to be [A] transpose
+		# define [P] to be [A]^t[A]
+		# define [S] to be [A]^t[SCORE]
+		# equation is now [P][OPR] = [S]
+		# refactor [P] as [L][L]^t using cholesky
+		# [L] is a lower triangular matrix and [L]^t an upper
+		# Therefore [L][L]^t[OPR] = [S]
+		# define [Y] = [L]^t[OPR]
+		# equation is now [L][Y] = [S]
+		# find [Y] through forward substitution
+		# find [OPR] through back substitution
+
+		def opr_calculate(a, score)
+			p = a.t * a
+			s = a.t * score
+
+			l = p.cholesky_factor
+
+			# l.output
+			# l.t.output
+
+			y = forward_substitute l, s
+			back_substitute l.t, y
+		end
+
+		# Offensive power rating: the average amount of points that a team contributes to their alliance's score.
+		# This is high for a good team.
+		def opr(recalc = false)
+			if !@opr || recalc || @opr_recalc
+				a = alliance_smooshey @ared, @ablue
+				score = alliance_smooshey @scorered, @scoreblue
+				
+				@opr = opr_calculate a, score
+				@opr_recalc = false
+			end
+			
+			@opr
+		end
+
+		# Defensive power rating: the average amount of points that a team lets the other alliance score.
+		# This is low for a good team.
+		def dpr(recalc = false)
+			if !@dpr || recalc || @dpr_recalc
+				a = alliance_smooshey @ared, @ablue
+				score = alliance_smooshey @scoreblue, @scorered # intentionally swapped, that's how dpr works.
+				
+				@dpr = opr_calculate a, score
+				@dpr_recalc = false
+			end
+			
+			@dpr
+		end
+
+		# Calculated contribution to winning margin: the average amount of points that a team contributes to their alliance's winning margin.
+		# This is high for a good team.
+		def ccwm(recalc = false)
+			if !@ccwm || recalc || @ccwm_recalc
+				a = alliance_smooshey @ared, @ablue
+				
+				red_wm = Matrix.build(@scorered.row_size, @scorered.column_size) do |row, column|
+					@scorered[row, column] - @scoreblue[row, column]
+				end
+				
+				blue_wm = Matrix.build(@scoreblue.row_size, @scoreblue.column_size) do |row, column|
+					@scoreblue[row, column] - @scorered[row, column]
+				end
+
+				score = alliance_smooshey red_wm, blue_wm
+
+				@ccwm = opr_calculate a, score
+				@ccwm_recalc = false
+			end
+			
+			@ccwm
+		end
+	end
+end

metadata

@@ -1,16 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: opr-calc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kristofer Rye
 - Christopher Cooper
+- Sam Craig
 autorequire: 
 bindir: bin
 cert_chain: []
 date: 2014-01-25 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: 
 executables: []
@@ -18,6 +47,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/opr-calc.rb
+- lib/opr-calc/matrix.rb
+- lib/opr-calc/score_set.rb
 homepage: https://github.com/team461WBI/opr-calc
 licenses:
 - GPL-3.0
@@ -38,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: A tool for calculating OPR and other scouting stats for FRC teams.