physics_calculator 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in physics_calculator.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/physics_calculator.rb

@@ -0,0 +1,319 @@
+require "physics_calculator/version"
+
+module PhysicsCalculator
+
+  include Math
+  require 'matrix'                          # methods for matrix and vector manipulation
+
+  # extend standard library vector class
+
+  class ::Vector
+
+    # dot_product as alias for cross product
+    def dot_product(v)
+      self.inner_product(v)
+    end
+
+    # define cross product
+    def cross_product_(v)
+      raise ArgumentError, 'Vectors must be 3D' if (self.size != 3 || v.size != 3)
+      Vector.[](self[1]*v[2] - self[2]*v[1], self[2]*v[0] - self[0]*v[2], self[0]*v[1] - self[1]*v[0])
+    end
+
+    # define distance between two vectors
+    def distance(v)
+      (self - v).r
+    end
+
+    # define unit vector pointing from v to self
+    def unit_(v)
+      (self - v).normalize
+    end
+
+  end
+
+  # Physical Constants (SI Units)
+
+  SPEED_LIGHT = 299792458.0               # speed of light in a vacuum (m/s)
+  PLANCK = 6.62606957e-34                 # planck's constant (J*s)
+  PLANCK_REDUCED = 1.054571726e-34        # reduced planck's constant
+  PERMITTIVITY = 8.854187817e-12          # vacuum permittivity (F/m)
+  PERMEABILITY = 1.2566370614e-6          # vacuum permeability ((V*s)/(A*m))
+  CHARGE_ELEMENTARY = 1.602176565e-19     # elementary charge (C)
+  FINE_STRUCTURE = 7.2973525698e-3        # fine structure constant (dimensionless)
+  MASS_ELECTRON = 9.10938215e-31          # electron rest mass (kg)
+  MASS_PROTON = 1.672621777e-27           # proton rest mass (kg)
+  MASS_NEUTRON = 1.674927351e-27          # neutron rest mass (kg)
+  MASS_EARTH = 5.97217e24                 # mass of the Earth (kg)
+  MASS_SUN = 1.98855e30                   # mass of the Sun (kg)
+  MASS_MOON = 7.3477e22                   # mass of the Moon (kg)
+  GRAVITATIONAL = 6.67384e-11             # gravitational constant ((N*m^2)/kg^2))
+  ACCELERATION_GRAVITY = 9.80665          # acceleration due to gravity on Earth's surface (m/s^2)
+  BOLTZMANN = 1.3806488e-23               # Boltzmann constant
+  ENERGY_BINDING = -2.1799e-19            # energy of ground state of electron in hydrogen atom (Joules)
+  RYDBERG = 1.09739e7                     # Rydberg constant (1/m)
+
+  # Aliases for convenience
+
+  C = SPEED_LIGHT
+  G = GRAVITATIONAL
+  H = PLANCK_REDUCED
+  I = Complex::I
+  X_ = Vector.[](1,0,0)
+  Y_ = Vector.[](0,1,0)
+  Z_ = Vector.[](0,0,1)
+  ACCELERATION_GRAVITY_ = -ACCELERATION_GRAVITY*Z_
+
+
+  # arguments with suffix _ expect 3 dimensional vectors
+  # arguments expect SI units
+
+
+  # classical mechanics
+
+
+  # gravitational force on mass1 at position1_ due to mass2 at position2_ (vector in Newtons)
+  def force_gravity_(mass1, position1_, mass2, position2_)
+    ((-G * mass1 * mass2) / (position1_.distance(position2_)**2)) * position1_.unit_(position2_)
+  end
+
+  # weight of mass at surface of Earth with -Z_ pointing at the center of Earth (vector in Newtons)
+  def force_weight_(mass)
+    ACCELERATION_GRAVITY_ * mass
+  end
+
+  # position of object under constant acceleration_ at time given initial conditions position0_ and velocity0_ (vector in meters)
+  def position_constant_acceleration_(position0_, velocity0_, acceleration_, time)
+    0.5*acceleration_*time**2 + velocity0_ * time + position0_
+  end
+
+  # velocity of object under constant acceleration_ at time given initial condition velocity0_ (vector in m / s)
+  def velocity_constant_acceleration_(velocity0_, acceleration_, time)
+    velocity0_ + acceleration_ * time
+  end
+
+  # position of object under acceleration due to gravity at time given initial conditions position0_ and velocity0_ (vector in meters)
+  def position_gravity_acceleration_(position0_, velocity0_, time)
+    position_constant_acceleration_(position0_, velocity0_, ACCELERATION_GRAVITY_, time)
+  end
+
+  # velocity of object under acceleration due to gravity at time given initial condition velocity0_ (vector in m / s)
+  def velocity_gravity_acceleration_(velocity0_, time)
+    velocity_constant_acceleration_(velocity0_, ACCELERATION_GRAVITY_, time)
+  end
+
+  # linear momentum of mass at velocity_ (vector in kg * m^2)
+  def momentum_(mass, velocity_)
+    mass * velocity_
+  end
+
+  # kinetic energy of mass at velocity_ (scalar in Joules)
+  def energy_kinetic(mass, velocity_)
+    0.5*mass*(velocity_.r)**2
+  end
+
+  # torque from applying f_ at position_ around axis_  (vector in N * m)
+  def torque_(axis_, position_, force_)
+    (position_ - axis_).cross_product_(force_)
+  end
+
+  # angular momentum from momentum mass*velocity_ around axis vector (vector in J * s)
+  def angular_momentum_(axis_, position_, mass, velocity_)
+    (position_ - axis_).cross_product_(momentum_(mass,velocity_))
+  end
+
+  # angular momentum of rotating rigid body with moment_inertia rotating at angular_velocity_ (vector in J * s)
+  def angular_momentum_rigid_(moment_inertia, angular_velocity_)
+    moment_inertia * angular_velocity_
+  end
+
+  # reduced mass of mass1 and mass2 (scalar in kilograms)
+  def mass_reduced(mass1, mass2)
+    (Float(mass1*mass2))/(mass1 + mass2)
+  end
+
+  # moment of inertia using parallel axis theorem using mass with moment_inertia_cm with axis_distance between the center of mass and axis of rotation (scalar in kg * m^2)
+  def moment_inertia_parallel_axis(moment_inertia_cm, mass, axis_distance)
+    moment_inertia_cm + mass*axis_distance**2
+  end
+
+  # moment of inertia of mass at distance away from axis of rotation(scalar in kg * m^2)
+  def moment_inertia_point_mass(mass, distance)
+    mass * distance**2
+  end
+
+  # moment of inertia of mass1 and mass2 at distance away from axis of rotation (scalar in kg * m^2)
+  def moment_inertia_2_point_mass(mass1, mass2, distance)
+    mass_reduced(mass1, mass2)*distance**2
+  end
+
+  # moment of inertia of rod with length and mass rotating about center of mass (scalar in kg * m^2)
+  def moment_inertia_rod(mass, length)
+    (mass*length**2) / 12.0
+  end
+
+  # moment of inertia of hollow sphere with radius and mass rotating about center of mass (scalar in kg * m^2)
+  def moment_inertia_sphere(mass, radius)
+    (2*mass*radius**2) / 3.0
+  end
+
+  # moment of inertia of solid ball with radius and mass rotating about center of mass (scalar in kg * m^2)
+  def moment_inertia_ball(mass, radius)
+    (2*mass*radius**2) / 5.0
+  end
+
+
+  # quantum mechanics
+
+
+  # de Broglie wavelength for a particle with momentum p (scalar in meters)
+  def wavelength_de_broglie(momentum)
+    PLANCK / momentum
+  end
+
+  # Hermite polynomial of degree n evaluated at x (helper for QHO eigenstates)
+  def hermite_polynomial(n, x)
+    if n == 0
+      1
+    elsif n == 1
+      2*x
+    else
+      (2*x*hermite_polynomial(n-1, x) - 2*(n-1)*hermite_polynomial(n-2, x))
+    end
+  end
+
+  # one dimensional quantum harmonic oscillator nth eigenstate for particle with mass, frequency, and position (scalar dimensionless)
+  def eigenstate_qho(n, mass, frequency, position)
+    xi = Math.sqrt((mass*frequency) / H)*position
+    (((mass*frequency)/(PI*H))**0.25)*(((2**n)*Math.gamma(n+1))**0.5)*hermite_polynomial(n, xi)*Math.exp((-xi**2) / 2)
+  end
+
+  # one dimensional quantum harmonic oscillator nth eigenstate energy for particle with mass, and frequency (scalar in Joules)
+  def energy_qho(n, frequency)
+    (n + 0.5) * H * frequency
+  end
+
+  # eigenstate of particle in one dimensional infinite square well potential from 0 to width with mass and position (scalar dimensionless)
+  def eigenstate_infinite_well(n, width, position)
+    sqrt(2.0 / width) * sin((n * PI * position) / width)
+  end
+
+  # energy of particle in one dimensional infinite square well potential from 0 to width with mass (scalar in Joules)
+  def energy_infinite_well(n, width, mass)
+    (n**2 * PI**2 * H**2) / (2 * mass * width**2)
+  end
+
+  # energy of the nth (n = 1, 2, 3 ...) state of the electron in a hydrogen atom according to the Bohr model (scalar in Joules)
+  def energy_bohr(n)
+    ENERGY_BINDING / n**2
+  end
+
+  # wavelength of light emitted in transition of electron from n_initial state to n_final state according to the Rydberg formula (scalar in meters)
+  def wavelength_rydberg(n_initial, n_final)
+    1.0 / (RYDBERG*(1.0 / (n_final**2) - 1.0 / (n_initial**2))).abs
+  end
+
+
+  # electricity and magnetism
+
+
+  # Lorentz force on particle with charge moving at velocity_ through electric_field_ and magnetic_field_
+  def force_lorentz_(charge, velocity_, electric_field_, magnetic_field_)
+    charge * (electric_field_ + velocity_.cross_product_(magnetic_field_))
+  end
+
+  # force felt by charge1 at position1_ due to charge2 at position2_
+  def force_coulombs_law_(charge1, position1_, charge2, position2_)
+    (((1/(4*PI*PERMITTIVITY))*charge1*charge2)/(position1_.distance(position2_)**2))*position1_.unit_(position2_)
+  end
+
+  # electric field at position_ due to point charge at charge_position_ (vector in N / C)
+  def electric_field_point_charge_(charge, charge_position_, position_)
+    (((1/(4*PI*PERMITTIVITY))*charge)/(position_.distance(charge_position_)**2))*position_.unit_(charge_position_)
+  end
+
+  # magnetic field at position_ due to point charge at charge_position_ moving at charge_velocity_ (vector in Teslas)
+  def magnetic_field_point_charge_(charge, charge_position_, charge_velocity_, position_)
+    (PERMEABILITY*charge)/(4*PI*position_.distance(charge_position_)**2)*charge_velocity_.cross_product_(position_.unit_(charge_position_))
+  end
+
+  # equivalent resistance of resistance1 and resistance2 in series (scalar in ohms)
+  def resistance_series(resistance1, resistance2)
+    resistance1+resistance2
+  end
+
+  # equivalent resistance of resistance1 and resistance2 in parallel (scalar in ohms)
+  def resistance_parallel(resistance1, resistance2)
+    Float(resistance1*resistance2)/(resistance1+resistance2)
+  end
+
+  # equivalent inductance of inductance1 and inductance2 in series (scalar in henry)
+  def inductance_series(inductance1, inductance2)
+    inductance1+inductance2
+  end
+
+  # equivalent inductance of inductance1 and inductance2 in parallel (scalar in henry)
+  def inductance_parallel(inductance1, inductance2)
+    Float(inductance1*inductance2)/(inductance1+inductance2)
+  end
+
+  # equivalent capacitance of capacitance1 and capacitance2 in series (scalar in Farads)
+  def capacitance_series(capacitance1, capacitance2)
+    Float(capacitance1*capacitance2)/(capacitance1+capacitance2)
+  end
+
+  # equivalent capacitance of capacitance1 and capacitance2 in parallel (scalar in Farads)
+  def capacitance_parallel(capacitance1, capacitance2)
+    capacitance1+capacitance2
+  end
+
+  # voltage due to current across resistance (scalar in Volts)
+  def voltage_ohm_law(current, resistance)
+    current*resistance
+  end
+
+
+  # special relativity
+
+
+  # lorentz factor for object moving at velocity (scalar dimensionless)
+  def lorentz_factor(speed)
+    (1.0 / (Math.sqrt(1.0-(speed/C)**2)))
+  end
+
+  # time dilation for an object moving at velocity over time_interval (scalar in seconds)
+  def time_dilation(time_interval, speed)
+    lorentz_factor(speed)*time_interval
+  end
+
+  # length contraction for an object with length moving at speed (scalar in meters)
+  def length_contraction(length, speed)
+    length / lorentz_factor(speed)
+  end
+
+  # relativistic mass of an object moving at speed (scalar in kilograms)
+  def mass_relativistic(mass, speed)
+    lorentz_factor(speed)*mass
+  end
+
+  # relativistic momentum of an object with mass moving at speed (scalar in kg * m / s)
+  def momentum_relativistic(mass, speed)
+    lorentz_factor(speed) * mass * speed
+  end
+
+  # rest energy of mass (scalar in Joules)
+  def energy_rest(mass)
+    mass*C**2
+  end
+
+  # energy of a photon with frequency (scalar in Joules)
+  def energy_photon(frequency)
+    PLANCK*frequency
+  end
+
+  # momentum of a photon with frequency (scalar in kg * m / s)
+  def momentum_photon(frequency)
+    energy_photon(frequency)/C
+  end
+
+end

data/lib/physics_calculator/version.rb

@@ -0,0 +1,3 @@
+module PhysicsCalculator
+  VERSION = "0.0.1"
+end

data/physics_calculator.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "physics_calculator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "physics_calculator"
+  s.version     = PhysicsCalculator::VERSION
+  s.date        = '2013-09-04'
+  s.authors     = ["Cristian Derr"]
+  s.email       = ["cristian.j.derr@gmail.com"]
+  s.license     = 'MIT'
+  s.summary     = "Physics Calculator"
+  s.description = "Gem that contains many useful methods using physics formulas. Many of them use the vector standard library. Formulas range from classical mechanics, quantum mechanics, electricity and magnetism, and special relativity."
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: physics_calculator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Cristian Derr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &25960440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *25960440
+description: Gem that contains many useful methods using physics formulas. Many of
+  them use the vector standard library. Formulas range from classical mechanics, quantum
+  mechanics, electricity and magnetism, and special relativity.
+email:
+- cristian.j.derr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/physics_calculator.rb
+- lib/physics_calculator/version.rb
+- physics_calculator.gemspec
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Physics Calculator
+test_files: []