eletro 0.0.2 → 0.1.0

data/README.rdoc

@@ -16,8 +16,42 @@ Eletric Stuff, Ohm Law, Resistor Colors, Karnaugh Maps...
     -> 1kΩ   --BKR--
 
 
+    eletro 4k7
+
+    -> 4.7kΩ   --YVR--
+
+
+
 With *SH colors!
 
+
+== Power Supply (Source)
+
+Calculates load network on a PS.
+Simbling loads mean serial, simbling arrays parallel.
+
+    s = Source.new("12dc")
+    s << Resistor.new("100")
+    s << [Resistor.new("100"), Resistor.new("100")]
+    s << [Resistor.new("100"), Resistor.new("200")]
+
+    s.sum_net
+    => Resistor 54.5454Ω
+
+    s.i
+    => 0.220mA
+
+    s << Resistor.new("100")
+    s << [Resistor.new("100"), Resistor.new("100")]
+    s << [Resistor.new("100"), [Resistor.new("100"), Resistor.new("100")]]
+
+    s.sum_net
+    => Resistor 33.3333Ω
+
+    s.i
+    => 0.360mA
+
+
 == Ohm`s Law
 
 TBF

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/eletro.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{eletro}
-  s.version = "0.0.2"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Marcos Piccinini"]
-  s.date = %q{2010-11-10}
+  s.date = %q{2010-11-11}
   s.default_executable = %q{eletro}
   s.description = %q{Eletric Stuff, Ohm Law, Resistor Colors, Karnaugh Maps and other gems on Ruby}
   s.email = %q{x@nofxx.com}
@@ -26,11 +26,23 @@ Gem::Specification.new do |s|
      "bin/eletro",
      "eletro.gemspec",
      "lib/eletro.rb",
+     "lib/eletro/capacitor.rb",
+     "lib/eletro/diode.rb",
+     "lib/eletro/helpers/color_code.rb",
+     "lib/eletro/ic.rb",
+     "lib/eletro/inductor.rb",
+     "lib/eletro/logic.rb",
      "lib/eletro/ohm.rb",
+     "lib/eletro/part.rb",
      "lib/eletro/resistor.rb",
+     "lib/eletro/source.rb",
+     "lib/eletro/transistor.rb",
      "spec/colour_test",
+     "spec/eletro/capacitor_spec.rb",
      "spec/eletro/ohm_spec.rb",
+     "spec/eletro/part_spec.rb",
      "spec/eletro/resistor_spec.rb",
+     "spec/eletro/source_spec.rb",
      "spec/eletro_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -41,8 +53,11 @@ Gem::Specification.new do |s|
   s.summary = %q{Eletric Helpers on Ruby}
   s.test_files = [
     "spec/spec_helper.rb",
+     "spec/eletro/source_spec.rb",
+     "spec/eletro/capacitor_spec.rb",
      "spec/eletro/ohm_spec.rb",
      "spec/eletro/resistor_spec.rb",
+     "spec/eletro/part_spec.rb",
      "spec/eletro_spec.rb"
   ]
 

data/lib/eletro.rb

@@ -1,6 +1,15 @@
 
+require "eletro/helpers/color_code"
 require "eletro/ohm"
+require "eletro/part"
+require "eletro/diode"
+require "eletro/logic"
+require "eletro/source"
 require "eletro/resistor"
+require "eletro/inductor"
+require "eletro/capacitor"
+require "eletro/transistor"
+require "eletro/ic"
 
 module Eletro
 
@@ -8,7 +17,7 @@ module Eletro
     params = args.join
     if params =~ /A|mA/  # need to improve
     else
-      puts Resistor.new(params).to_s
+      puts Resistor.new(params).pretty_output
     end
   end
 

data/lib/eletro/capacitor.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+module Eletro
+
+  class Capacitor < Part
+    attr_accessor :polarized
+
+    include ColorCode
+
+    def initialize(*args)
+      parse_color_code(args.join)
+    end
+
+    def parse txt
+      if m = txt.match(/#{mult.keys.join('|')}/)
+        txt.gsub!(/#{m[0]}/, ".")
+        m = mult[m[0]]
+      else
+        st, nd, m = txt.split(//)
+        m ||= 0
+        m = m.to_i #(10**-(m.to_i))
+      end
+      num = ("#{st}#{nd}#{'0' * m}").to_f * mult['p']
+      num
+    end
+
+    def unit
+      "F"
+    end
+
+    def mult
+      { 'n' => 10e-6, 'u' => 10e-9, 'p' => 10e-12 }
+    end
+
+    def format
+      m = 'p'
+      mult.keys.reverse.each do |k|
+        m = k if value >= mult[k]
+      end
+      # v = if value > mult[0]
+      #   "%g" % @value
+      # elsif value < 1000000
+      #   "%gk" % (@value/1000)
+      # else
+      #   "%gm" % (@value/1000000)
+      # end
+      out = "%g#{m}#{unit}" %  (value/mult[m]).round
+      out += " ± #{@precision}%" if @precision
+      out
+    end
+
+    def polarized?
+      !!@polarized
+    end
+
+  end
+
+
+end

data/lib/eletro/diode.rb

@@ -0,0 +1,12 @@
+module Eletro
+
+  class Diode < Part
+
+
+  end
+
+  class LED < Diode
+
+
+  end
+end

data/lib/eletro/helpers/color_code.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+module Eletro
+
+  COLOR = true
+
+  module ColorCode
+    attr_reader :color
+
+    CODE = [:k, :b, :r, :o, :y, :g, :u, :v, :a, :w, :l, :s]
+    COLORS = {
+      :k => :black,
+      :b => :brown,
+      :r => :red,
+      :o => :orange,
+      :y => :yellow,
+      :g => :green,
+      :u => :blue,
+      :v => :violet,
+      :a => :gray,
+      :w => :white,
+      :l => :gold,
+      :s => :silver}
+
+    PRECISION = [nil, 1, 2, nil, nil, 0.5, 0.25, 01, 0.05, nil, 5, 10, 20]
+
+    alias :colors :color
+
+    def parse_color_code(params)
+      return if params.empty?
+      if params =~ /\d/
+        # m = params.match(/(\d*[,|{k|m|g}|\.]?\d*)\s*(k|m|g)?/)
+        # return unless m
+        @value = parse(params)
+        @color = value2color(@value)
+      else
+        @color = params.split(//)
+        @value = color2value(@color)
+      end
+    end
+
+    def calc char
+      CODE.index(char.downcase.to_sym)
+    end
+
+    def color2value chars
+      out = calc(chars[0])
+      out = (out.to_s + calc(chars[1]).to_s).to_f
+      out *= (10 ** (calc(chars[2])))
+      if chars.size > 3
+        @precision = PRECISION[calc(chars[3])]
+      else
+        #out *= (10 ** (calc(chars[2])))
+      end
+      out
+    end
+
+    def value2color value
+      st, nd, *rest = value.to_s.split(//)
+      out = [CODE[st.to_i], CODE[nd.to_i]]
+      index = 1 if rest.size == 3 # ugly... sleepy... fix....
+      index ||= (value ** 0.1).round
+      out << CODE[index]
+      out
+    end
+
+
+    def rgblize color
+      s = case color.to_s.downcase.to_sym
+        when :k then  "\e[40m"
+        when :b then  "\e[0;33m"
+        when :r then  "\e[41m"
+        when :g then  "\e[42m"
+        when :y then  "\e[1;33m"
+        when :o then  "\e[43m"
+        when :u then  "\e[44m"
+        when :v then  "\e[45m"
+        when :w then  "\e[47m"
+        when :a then  "\e[31m"
+        else ".."
+      end
+      s += "#{color.to_s.upcase}\e[0m"
+    end
+
+
+    def bold(txt);      "\e[2m#{txt}\e[0m";    end
+
+
+  end
+
+
+end

data/lib/eletro/ic.rb

@@ -0,0 +1,8 @@
+
+module Eletro
+
+  class IC
+
+  end
+
+end

data/lib/eletro/inductor.rb

@@ -0,0 +1,7 @@
+module Eletro
+
+  class Inductor < Part
+
+  end
+
+end

data/lib/eletro/logic.rb

@@ -0,0 +1,9 @@
+
+module Eletro
+
+  class Logic
+
+  end
+end
+
+

data/lib/eletro/part.rb

@@ -0,0 +1,71 @@
+module Eletro
+
+  class Part
+    attr_accessor :value, :unit, :p0, :p1, :v
+
+    def p0
+      @p0 ||= :gnd
+    end
+
+    def p1
+      @p1 ||= :pwd
+    end
+
+    def *(other)
+      self.class.new(self.value*other)
+    end
+
+    def +(other)
+      self.class.new(self.value+other)
+    end
+
+    def /(other)
+      self.class.new(self.value/other)
+    end
+
+    def -(other)
+      self.class.new(self.value-other)
+    end
+
+    def abs
+      self.value.abs
+    end
+
+    def to_f;      @value;         end
+    def to_i;      @value.to_i;    end
+
+    def unit;    end
+    def to_s
+      "#{@value}#{unit}"
+    end
+
+
+    def coerce(other);      [other, @value];    end
+
+    def round
+      # todo, table standard values, find nearest...
+    end
+
+    def method_missing(*args)
+      txt = args.join
+      if txt =~ /p\d+/
+        if txt =~ /=/
+          var, value = txt.split("=")
+          instance_variable_set("@#{var}", value)
+          self.class.instance_eval do
+            define_method(var, lambda { instance_variable_get("@#{var}") })
+          end
+        else
+          respond_to?(txt) ? send(args.join) : nil
+        end
+      else
+        raise NoMethodError.new("undefined method `#{args.join}' " +
+        "for #{self.inspect}:#{self.class.name}")
+      end
+
+    end
+
+  end
+
+
+end

data/lib/eletro/resistor.rb

@@ -4,80 +4,30 @@
 
 module Eletro
 
-  COLOR = true
+  class Resistor < Part
 
-  class Resistor
-    attr_reader :value, :color
-
-    UNIT = 'Ω'
-    MULT = /k|m|g/
-
-    CODE = [:k, :b, :r, :o, :y, :g, :u, :v, :a, :w, :l, :s]
-    COLORS = {
-      :k => :black,
-      :b => :brown,
-      :r => :red,
-      :o => :orange,
-      :y => :yellow,
-      :g => :green,
-      :u => :blue,
-      :v => :violet,
-      :a => :gray,
-      :w => :white,
-      :l => :gold,
-      :s => :silver}
-
-    PRECISION = [nil, 1, 2, nil, nil, 0.5, 0.25, 01, 0.05, nil, 5, 10, 20]
+    include ColorCode
 
     def initialize(*args)
-      params = args.join
-      if params =~ /\d/
-        # m = params.match(/(\d*[,|{k|m|g}|\.]?\d*)\s*(k|m|g)?/)
-        # return unless m
-        @value = parse(params)
-        @color = value2color(@value)
-      else
-        @color = params.split(//)
-        @value = color2value(@color)
-      end
+      parse_color_code(args.join)
     end
 
     def parse txt
-      if mult = txt.match(MULT)
-        txt.gsub!(/#{mult[0]}/, ".") #if txt =~ /#{MULT}\d/
-        mult = { 'k' => 1000, 'm' => 10000000 }[mult[0]]
+      if m = txt.match(/#{mult.keys.join('|')}/)
+        txt.gsub!(/#{m[0]}/, ".")
+        m = mult[m[0]]
       end
       num = txt.to_f
-      num *= mult if mult
+      num *= m if m
       num
     end
 
-    alias :colors :color
-
-
-    def calc char
-      CODE.index(char.downcase.to_sym)
+    def unit
+      "Ω"
     end
 
-    def color2value chars
-      out = calc(chars[0])
-      out = (out.to_s + calc(chars[1]).to_s).to_f
-      out *= (10 ** (calc(chars[2])))
-      if chars.size > 3
-        @precision = PRECISION[calc(chars[3])]
-      else
-        #out *= (10 ** (calc(chars[2])))
-      end
-      out
-    end
-
-    def value2color value
-      st, nd, *rest = value.to_s.split(//)
-      out = [CODE[st.to_i], CODE[nd.to_i]]
-      index = 1 if rest.size == 3 # ugly... sleepy... fix....
-      index ||= (value ** 0.1).round
-      out << CODE[index]
-      out.map(&:upcase)
+    def mult
+      { 'k' => 10e2, 'm' => 10e5 }
     end
 
     def format
@@ -88,40 +38,17 @@ module Eletro
       else
         "%gm" % (@value/1000000)
       end
-      out = "#{v}#{UNIT}"
+      out = "#{v}#{unit}"
       out += " ± #{@precision}%" if @precision
       out
     end
 
-    def to_s
+    def pretty_output
       out = format
       out += "   --"
-      @color.each do |c|
-        out +=  COLOR ? rgblize(c) : c
-      end
+      @color.each { |c| out +=  COLOR ? rgblize(c) : c }
       out + "--"
-
     end
 
-
-    def rgblize color
-      s = case color.downcase.to_sym
-        when :k then  "\e[40m"
-        when :b then  "\e[0;33m"
-        when :r then  "\e[41m"
-        when :g then  "\e[42m"
-        when :y then  "\e[1;33m"
-        when :o then  "\e[43m"
-        when :u then  "\e[44m"
-        when :v then  "\e[45m"
-        when :w then  "\e[47m"
-        when :a then  "\e[31m"
-        else ".."
-      end
-      s += "#{color}\e[0m"
-    end
-
-    def bold(txt);      "\e[2m#{txt}\e[0m";    end
-
   end
 end

data/lib/eletro/source.rb

@@ -0,0 +1,84 @@
+module Eletro
+
+  class Source < Part
+
+    attr_accessor :hz, :v, :circuits
+
+
+    def initialize(*args)
+      params = args.join
+      @v = params.match(/(\d*)/)[1].to_i
+      @hz = params =~ /ac|AC/ ? 60 : 0
+      @circuits = []
+    end
+
+
+
+    def <<(part, circuit=nil)
+      if circuit
+
+      else
+        circuits << (part.is_a?(Array) ? part : [part])
+      end
+    end
+
+    def i
+      @v / sum_net.to_f
+    end
+
+    def w
+      @v * i
+    end
+
+    #
+    # Logic:
+    #
+    # Resistor on an array are in series, sum.  [100, 100] => [200]
+    # Arrays in arrays are parallel connections. [[100], [100]] => [50]
+    #
+    # Mixed example (rounded):
+    #
+    # [[100], [100, 100], [100, 100]]
+    # [[100], [200], [200]]
+    # [[66], [200]]
+    # [[50]] => 50 ohms
+    #
+    def sum_net
+      # Memoize
+      @sum_net ||= calc_sum_net
+    end
+
+    def calc_sum_net(ary=circuits)
+      ary.map! do |i|
+        if i.is_a?(Array)
+          i = [calc_sum_net(i)] unless i.select { |c| c.is_a?(Array) }.empty?
+          i.size > 1 ? serial_sum(i) : i[0]#.value
+        else;  i
+        end
+      end
+      ary.size == 1 ? ary[0] : parallel_sum(*ary)
+    end
+
+    def parallel_sum(r1, r2, *rest)
+      sum = r1 * r2 / (r1 + r2)
+      rest.empty? ? sum : parallel_sum(*rest.unshift(sum))
+    end
+
+    def serial_sum(ary)
+      ary.reduce(0) { |i, c| i + c }
+    end
+
+    #just for fun
+    def acdc
+      dc? || (@v /= 2)
+    end
+
+    def dc?
+      @hz.zero?
+    end
+
+    def ac?
+      !dc?
+    end
+  end
+end

data/lib/eletro/transistor.rb

@@ -0,0 +1,8 @@
+module Eletro
+
+  class Transistor < Part
+
+    
+  end
+
+end

data/spec/eletro/capacitor_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Eletro::Capacitor" do
+
+  let(:rs) { Capacitor.new }
+
+  describe "Value" do
+
+    it "should not be polarized" do
+      c = Capacitor.new
+      c.should_not be_polarized
+    end
+
+    it "should instantiate 47" do
+      r = Capacitor.new("47")
+      r.value.should be_within(220.0).of(0.1)
+      r.format.should eql("47pF")
+    end
+
+    it "should instantiate 102" do
+      r = Capacitor.new("102")
+      r.value.should be_within(220.0).of(0.1)
+      r.format.should eql("1uF")
+    end
+
+
+  end
+
+end

data/spec/eletro/ohm_spec.rb

@@ -33,19 +33,19 @@ describe "Eletro::Ohm" do
     it "should calc V if I have [I, R]" do
       o.i = 0.048
       o.r = 250
-      o.v.should be_close(12.0, 0.01)
+      o.v.should be_within(12.0).of(0.01)
     end
 
     it "should calc I if I have [V, R]" do
       o.v = 12
       o.r = 250
-      o.i.should be_close(0.048, 0.001)
+      o.i.should be_within(0.048).of(0.001)
     end
 
     it "should calc V if I have [I, R]" do
       o.i = 0.048
       o.r = 250
-      o.v.should be_close(12.0, 0.01)
+      o.v.should be_within(12.0).of(0.01)
     end
     # o.r.should eql(1)
 

data/spec/eletro/part_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Eletro::Part" do
+
+  let(:p) { Part.new}
+
+  it "should have pins" do
+    p.p0.should eql(:gnd)
+  end
+
+  it "should get dynamic" do
+    p.p99.should be_nil
+  end
+
+  it "should set dynamic" do
+    p.p99.should be_nil
+    p.p99 = :fu
+    p.p99.should eql('fu')
+  end
+
+
+end

data/spec/eletro/resistor_spec.rb

@@ -9,86 +9,86 @@ describe "Eletro::Resistor" do
 
     it "should instantiate 220 ohms" do
       r = Resistor.new("220")
-      r.value.should be_close(220.0, 0.1)
+      r.value.should be_within(220.0).of(0.1)
       r.format.should eql("220Ω")
     end
 
     it "should instantiate 100R ohms" do
       r = Resistor.new("100R")
-      r.value.should be_close(100.0, 0.1)
+      r.value.should be_within(100.0).of(0.1)
       r.format.should eql("100Ω")
     end
 
     it "should instantiate 1k ohms" do
       r = Resistor.new("1k")
-      r.value.should be_close(1000.0, 0.1)
+      r.value.should be_within(1000.0).of(0.1)
       r.format.should eql("1kΩ")
     end
 
     it "should instantiate 1k ohms" do
       r = Resistor.new("1000.0")
-      r.value.should be_close(1000.0, 0.1)
+      r.value.should be_within(1000.0).of(0.1)
       r.format.should eql("1kΩ")
     end
 
     it "should instantiate 1k ohms" do
       r = Resistor.new("1100.0")
-      r.value.should be_close(1100.0, 0.1)
+      r.value.should be_within(1100.0).of(0.1)
       r.format.should eql("1.1kΩ")
     end
 
     it "should instantiate 1k ohms" do
       r = Resistor.new("BBR")
-      r.value.should be_close(1100.0, 0.1)
+      r.value.should be_within(1100.0).of(0.1)
       r.format.should eql("1.1kΩ")
     end
 
     it "should instantiate 3.3k ohms" do
       r = Resistor.new("3.3k")
-      r.value.should be_close(3300.0, 0.1)
+      r.value.should be_within(3300.0).of(0.1)
       r.format.should eql("3.3kΩ")
     end
 
     it "should instantiate 4k7 ohms" do
       r = Resistor.new("4k7")
-      r.value.should be_close(4700.0, 0.1)
+      r.value.should be_within(4700.0).of(0.1)
       r.format.should eql("4.7kΩ")
     end
 
     it "should instantiate 1m5 ohms" do
       r = Resistor.new("1m5")
-      r.value.should be_close(15000000.0, 0.01)
-      r.format.should eql("15mΩ")
+      r.value.should be_within(15000000.0).of(0.1)
+      r.format.should eql("1.5mΩ")
     end
 
     it "should get colors for value" do
       r = Resistor.new("1k")
-      r.colors.join.should eql("BKR")
+      r.colors.join.should eql("bkr")
     end
 
     it "should get colors for value" do
       r = Resistor.new("10k")
-      r.colors.join.should eql("BKO")
+      r.colors.join.should eql("bko")
     end
 
     it "should get colors for value" do
       r = Resistor.new("1.1k")
-      r.colors.join.should eql("BBR")
+      r.colors.join.should eql("bbr")
     end
 
     it "should get colors for value" do
       r = Resistor.new("4k7")
-      r.colors.join.should eql("YVR")
+      r.colors.join.should eql("yvr")
     end
 
     it "should get colors for value" do
       r = Resistor.new("220")
-      r.colors.join.should eql("RRB")
+      r.colors.join.should eql("rrb")
     end
 
     it "should get colors for value" do
       r = Resistor.new("110")
-      r.colors.join.should eql("BBB")
+      r.colors.join.should eql("bbb")
     end
 
   end
@@ -97,37 +97,37 @@ describe "Eletro::Resistor" do
 
     it "should instantiate 3 chars" do
       r = Resistor.new("BKR")
-      r.value.should be_close(1000.0, 0.01)
+      r.value.should be_within(1000.0).of(0.01)
       r.format.should eql("1kΩ")
     end
 
     it "should instantiate 3 chars" do
       r = Resistor.new("BKO")
-      r.value.should be_close(10000.0, 0.01)
+      r.value.should be_within(10000.0).of(0.01)
       r.format.should eql("10kΩ")
     end
 
     it "should instantiate 3 chars" do
       r = Resistor.new("YVR")
-      r.value.should be_close(4700.0, 0.01)
+      r.value.should be_within(4700.0).of(0.01)
       r.format.should eql("4.7kΩ")
     end
 
     it "should instantiate 3 chars" do
       r = Resistor.new("YVR")
-      r.value.should be_close(4700.0, 0.01)
+      r.value.should be_within(4700.0).of(0.01)
       r.format.should eql("4.7kΩ")
     end
 
     it "should instantiate 4 chars" do
       r = Resistor.new("WWRS")
-      r.value.should be_close(9900.0, 0.01)
+      r.value.should be_within(9900.0).of(0.01)
       r.format.should eql("9.9kΩ ± 10%")
     end
 
     it "should instantiate 4 chars" do
       r = Resistor.new("BKRL")
-      r.value.should be_close(1000.0, 0.01)
+      r.value.should be_within(1000.0).of(0.01)
       r.format.should eql("1kΩ ± 5%")
     end
 
@@ -138,8 +138,8 @@ describe "Eletro::Resistor" do
 
     it "should print nicely" do
       r = Resistor.new("BKR")
-      r.value.should be_close(1000.0, 0.01)
-      r.to_s.should eql("1kΩ   --\e[0;33mB\e[0m\e[40mK\e[0m\e[41mR\e[0m--")
+      r.value.should be_within(1000.0).of(0.01)
+      r.pretty_output.should eql("1kΩ   --\e[0;33mB\e[0m\e[40mK\e[0m\e[41mR\e[0m--")
     end
 
   end

data/spec/eletro/source_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Eletro::Source" do
+
+  let(:ss) { Source.new }
+
+  describe "Instantiate" do
+
+    it "should instantiate 220 v" do
+      s = Source.new("220ac")
+      s.v.should eql(220)
+    end
+
+    it "should instantiate 220 AC" do
+      s = Source.new("220ac")
+      s.should be_ac
+    end
+
+    it "should instantiate 12vdc" do
+      s = Source.new("12vdc")
+      s.v.should eql(12)
+      s.should be_dc
+    end
+
+    it "should default to DC" do
+      s = Source.new("9")
+      s.should be_dc
+    end
+
+
+  end
+
+  describe "Circuits" do
+
+    describe "Loads" do
+
+      it "should add loads 1k" do
+        s = Source.new("12")
+        s << Resistor.new("1k")
+        s.i.should be_within(0.012).of(0.0001)
+      end
+
+      it "should add loads 100 ohm" do
+        s = Source.new("12")
+        s << Resistor.new("100")
+        s.i.should be_within(0.12).of(0.001)
+      end
+
+      it "should add two parallel loads" do
+        s = Source.new("12")
+        s << Resistor.new("2k")
+        s << Resistor.new("2k")
+        s.sum_net.should be_within(1000.0).of(0.01)
+        s.i.should be_within(0.012).of(0.0001)
+      end
+
+      it "should add three parallel loads" do
+        s = Source.new("12")
+        s << Resistor.new("1k")
+        s << Resistor.new("1k")
+        s << Resistor.new("100")
+        s.sum_net.should be_within(83.333).of(0.001)
+        s.i.should be_within(0.144).of(0.001)
+      end
+
+      it "should add mixed parallel/serial" do
+        s = Source.new("12")
+        s << Resistor.new("100")
+        s << [Resistor.new("100"), Resistor.new("100")]
+        s << [Resistor.new("100"), Resistor.new("100")]
+        s.circuits.should have(3).items
+        s.sum_net.should be_within(50.0).of(0.01)
+      end
+
+      it "should add mixed parallel/serial" do
+        s = Source.new("12")
+        s << Resistor.new("100")
+        s << [Resistor.new("100"), Resistor.new("100")]
+        s << [Resistor.new("100"), Resistor.new("200")]
+        s.circuits.should have(3).items
+        s.sum_net.should be_within(54.5454).of(0.01)
+      end
+
+
+      it "should add mixed parallel/serial" do
+        s = Source.new("12")
+        s << Resistor.new("100")
+        s << [Resistor.new("100"), Resistor.new("100")]
+        s << [[Resistor.new("100")], [Resistor.new("200")]]
+        s.circuits.should have(3).items
+        s.sum_net.should be_within(33.333).of(0.001)
+      end
+
+      it "should add mixed parallel series with more depth" do
+        s = Source.new("12")
+        s << Resistor.new("100")
+        s << [Resistor.new("100"), Resistor.new("100")]
+        s << [Resistor.new("100"), [Resistor.new("100"), Resistor.new("100")]]
+        s.circuits.should have(3).items
+        s.sum_net.should be_within(33.333).of(0.001)
+      end
+
+      # it "should add loads calcs w" do
+      #   s = Source.new("12")
+      #   s << Resistor.new("40")
+      #   s.w.should be_within(3.5999, 0.0001)
+      # end
+
+    end
+
+  end
+
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Marcos Piccinini
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-10 00:00:00 -02:00
+date: 2010-11-11 00:00:00 -02:00
 default_executable: eletro
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,11 +64,23 @@ files:
 - bin/eletro
 - eletro.gemspec
 - lib/eletro.rb
+- lib/eletro/capacitor.rb
+- lib/eletro/diode.rb
+- lib/eletro/helpers/color_code.rb
+- lib/eletro/ic.rb
+- lib/eletro/inductor.rb
+- lib/eletro/logic.rb
 - lib/eletro/ohm.rb
+- lib/eletro/part.rb
 - lib/eletro/resistor.rb
+- lib/eletro/source.rb
+- lib/eletro/transistor.rb
 - spec/colour_test
+- spec/eletro/capacitor_spec.rb
 - spec/eletro/ohm_spec.rb
+- spec/eletro/part_spec.rb
 - spec/eletro/resistor_spec.rb
+- spec/eletro/source_spec.rb
 - spec/eletro_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -105,6 +117,9 @@ specification_version: 3
 summary: Eletric Helpers on Ruby
 test_files: 
 - spec/spec_helper.rb
+- spec/eletro/source_spec.rb
+- spec/eletro/capacitor_spec.rb
 - spec/eletro/ohm_spec.rb
 - spec/eletro/resistor_spec.rb
+- spec/eletro/part_spec.rb
 - spec/eletro_spec.rb