darvin_functions 0.0.1 → 0.0.2

data/README.rdoc

@@ -0,0 +1,7 @@
+= Darvin_Functions
+
+Various functions for data processing, clean up and analysis
+
+== Copyright
+
+Copyright (c) 2010 Pedal Brain LLC.

data/ext/darvin_functions.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "darvin_functions.h"
+
+VALUE mDarvinFunctions;
+
+/********************************************************************************
+* roundNumber
+********************************************************************************/
+long roundNumber(double value) {
+	if (value == 0.0) return (0);									// don't mess with zero
+	if (value > 0.0) return ((long)(value+.5));		// positive number
+	return ((long)(value - .5));									// negative number
+}
+
+/* vself is a reference to the module or itself
+   varray is a Ruby array */
+VALUE mDarvinFunctions_workout_mmp(VALUE vself, VALUE varray) {
+  if (NIL_P(varray) || RARRAY_LEN(varray) == 0)
+    return varray;
+
+  VALUE new_array = rb_ary_new2(RARRAY_LEN(varray));
+
+  int  i, j, trail, offset;
+	long  *tot;															// total for specific interval
+	long  *maxTot;														// current sum for (i-1)
+
+	tot = ALLOCA_N(long, RARRAY_LEN(varray));			// allocate memory
+	maxTot = ALLOCA_N(long, RARRAY_LEN(varray));	// allocate memory
+
+	trail = 0;																		// trailing value
+	memset(maxTot, 	'\0', sizeof maxTot);					// init max totals by slot
+	
+	maxTot[0] = tot[0] = FIX2INT(RARRAY_PTR(varray)[0]);								// need first total (for single cell average), seed for others
+
+	/*
+	 * this loop initializes the totals for all slot averages (1-n)
+	 * assume numbers are 1 2 3 4 5
+	 * maxTot[] will be 1, 3, 6, 10, 15
+	 * The idea is each slot is initialized to the earliers total values, 
+	 * that is slot0 is initialized to 1
+	 *         slot1 is initialized to 1 + 2
+	 *         ...
+	 *         slot4 is initialized to 1 + 2 + 3 + 4 + 5
+	 */
+	for (i=1; i<RARRAY_LEN(varray); i++) 											// loop thru all the numbers
+		maxTot[i] = tot[i] = (tot[i-1] + FIX2INT(RARRAY_PTR(varray)[i]));	// compute tot for subsequent cells (starting at cell 0)
+
+	for (offset=1; offset<RARRAY_LEN(varray); offset++) {			// loop starting at index 1 (index-1 is the value to subtract)
+		trail = FIX2INT(RARRAY_PTR(varray)[offset-1]);										// this is the value to subtract from the beginning of the list
+		for (i=offset; i<RARRAY_LEN(varray); i++) {							// first time subtract 1 from all (except n list)
+			j = i - offset;														// subtract trail and add next value
+			tot[j] += (FIX2INT(RARRAY_PTR(varray)[i]) - trail);							// to temp variable
+			if (tot[j] > maxTot[j]) maxTot[j] = tot[j];// set maxTot for slot if larger
+		}
+	}
+	
+	for (i=0; i<RARRAY_LEN(varray); i++)											// first value divided by 1 (ignore it)
+    rb_ary_push(new_array, INT2FIX(roundNumber((double)maxTot[i] / (double)(i+1))));
+
+  return new_array;
+}
+
+void Init_darvin_functions(){
+  mDarvinFunctions = rb_define_module("DarvinFunctions");
+  rb_define_module_function(mDarvinFunctions, "workout_mmp", mDarvinFunctions_workout_mmp, 1);
+}

data/ext/darvin_functions.h

@@ -0,0 +1,20 @@
+#ifndef RUBY_DARVINFUNCTIONS
+#define RUBY_DARVINFUNCTIONS
+
+#include <ruby.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <locale.h>
+
+#if !defined(RSTRING_PTR)
+#define RSTRING_PTR(TC_s) (RSTRING(TC_s)->ptr)
+#endif
+#if !defined(RSTRING_LEN)
+#define RSTRING_LEN(TC_s) (RSTRING(TC_s)->len)
+#endif
+#if !defined(RARRAY_LEN)
+#define RARRAY_LEN(TC_a) (RARRAY(TC_a)->len)
+#endif
+
+#endif

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'darvin_functions'
+
+class Test::Unit::TestCase
+end

data/test/test_mmp.rb

@@ -0,0 +1,44 @@
+require 'helper'
+require 'benchmark'
+
+class TestMMP < Test::Unit::TestCase
+  MAX_POWER = 150000  # 1500.00 Watts as an integer
+  
+  context "test case" do
+    should "handle an empty array" do
+      assert_equal [], DarvinFunctions::workout_mmp([])
+    end
+
+    should "handle an array of one" do
+      assert_equal [10], DarvinFunctions::workout_mmp([10])
+    end
+
+    should "handle an array of two" do
+      assert_equal [10, 7], DarvinFunctions::workout_mmp([10, 4])
+    end
+
+    should "handle an array of three" do
+      assert_equal [10, 7, 5], DarvinFunctions::workout_mmp([10, 4, 2])
+    end
+  end
+  
+  context "Benchmark" do
+    
+    setup do
+      @size = 14400
+      @data = []
+      @size.times do |i|
+        value = Math.sin(i % Math::PI / 2)
+        @data << (value * MAX_POWER * 100 * rand).to_i / 100.0
+      end
+    end
+    
+    should "run under a minute" do
+      tms = Benchmark.bmbm(10) do |x|
+        x.report { DarvinFunctions::workout_mmp(@data) }
+      end.last
+      assert tms.total < 60, "#{@size} array took too long: #{tms.total} seconds is too long" # seconds
+    end
+  end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Darvin Bauer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-09 00:00:00 -05:00
+date: 2010-06-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,13 +36,15 @@ executables: []
 
 extensions: 
 - ext/extconf.rb
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
 files: 
-- ext/darvin_functions.bundle
+- ext/darvin_functions.h
+- ext/darvin_functions.c
 - ext/extconf.rb
+- README.rdoc
 has_rdoc: true
-homepage: http://github.com/pedalbrain/darvin_functions
+homepage: http://github.com/pedalbrain/Darvin_Functions
 licenses: []
 
 post_install_message: 
@@ -71,5 +73,6 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Various functions for data processing, clean up and analysis
-test_files: []
-
+test_files: 
+- test/helper.rb
+- test/test_mmp.rb