def calculateDistance( measurement1, measurement2 ): validUnitTypes = [ [ 'length', 'time' ], [ 'velocity', 'time' ], [ 'acceleration', 'time' ], [ 'jerk', 'time' ], [ 'jounce', 'time' ] ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'distance\' requires specific measurement types (see help)' ) time = arguments[ 'time' ] if 'length' in arguments: distance = arguments[ 'length' ] elif 'acceleration' in arguments: # acceleration and time distance = getProduct( [ 0.5, arguments[ 'acceleration' ], time, time ] ) elif 'jerk' in arguments: # jerk and time distance = calculateDistance( getProduct( [ 0.5, arguments[ 'jerk' ], time ] ), time ) elif 'jounce' in arguments: # jounce and time distance = calculateDistance( getProduct( [ 0.5, arguments[ 'jounce' ], time ] ), time ) else: # velocity and time distance = multiply( arguments[ 'velocity' ], time ) return distance.convert( 'meter' )
def calculateOrbitalVelocity( measurement1, measurement2 ): ''' To solve the velocity of a circular orbit, we need Newton's gravitational constant and two of the following three items: G = Newton's gravitational constant m = planetary mass (i.e., mass of the thing being orbited) r = orbit radius (the distance from the center of mass) T = orbital period ---- velocity in terms of mass and radius v = sqrt( G*m/r ) ---- velocity in terms of radius and period v = 2*pi*r/T ---- velocity in terms of mass and period v = ( 2*pi*cbrt( T^2*G*m/4*pi^2 ) ) / T ''' validUnitTypes = [ [ 'mass', 'time' ], [ 'length', 'time' ], [ 'mass', 'length' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'orbital_velocity\' requires specific measurement types (see help)' ) if 'mass' in arguments: mass = arguments[ 'mass' ] if 'length' in arguments: bRadius = True radius = arguments[ 'length' ] else: bRadius = False period = arguments[ 'time' ] else: # radius and period radius = arguments[ 'length' ] period = arguments[ 'time' ] velocity = divide( getProduct( [ 2, pi, radius ] ), period ) return velocity.convert( 'meter/second' ) if bRadius: # mass and radius velocity = getRoot( divide( multiply( getNewtonsConstant( ), mass ), radius ), 2 ) else: # mass and period term = divide( getProduct( [ period, period, getNewtonsConstant( ), mass ] ), getProduct( [ 4, pi, pi ] ) ) velocity = divide( getProduct( [ 2, pi, getRoot( term, 3 ) ] ), period ) return velocity.convert( 'meter/second' )
def calculateOrbitalPeriod( measurement1, measurement2 ): ''' To solve the period of a circular orbit, we need Newton's gravitational constant and two of the following three items: G = Newton's gravitational constant m = planetary mass (i.e., mass of the thing being orbited) r = orbit radius (the distance from the center of mass) v = orbital velocity ---- period in terms of radius and mass T = 2*pi*sqrt( r^3/G*m ) ---- period in terms of radius and velocity T = 2*pi*r/v ---- period in terms of mass and velocity T = 2*pi*G*m/v^3 ''' validUnitTypes = [ [ 'mass', 'length' ], [ 'velocity', 'length' ], [ 'mass', 'velocity' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'orbital_period\' requires specific measurement types (see help)' ) if 'mass' in arguments: mass = arguments[ 'mass' ] if 'length' in arguments: bRadius = True radius = arguments[ 'length' ] else: bRadius = False velocity = arguments[ 'velocity' ] else: # radius and velocity radius = arguments[ 'length' ] velocity = arguments[ 'velocity' ] period = divide( getProduct( [ 2, pi, radius ] ), velocity ) return period.convert( 'second' ) if bRadius: # radius and mass term = divide( getPower( radius, 3 ), multiply( getNewtonsConstant( ), mass ) ) period = getProduct( [ 2, pi, getRoot( term, 2 ) ] ) else: # velocity and mass period = divide( getProduct( [ 2, pi, getNewtonsConstant( ), mass ] ), getPower( velocity, 3 ) ) return period.convert( 'second' )
def calculateOrbitalMass( measurement1, measurement2 ): ''' To solve for the planetary mass for an object in a circular orbit, we need Newton's gravitational constant and two of the following three items: G = Newton's gravitational constant T = orbital period v = orbital velocity r = orbit radius (the distance from the center of mass) ---- mass in terms of period and velocity m = v^3*T/2*pi*G ---- mass in terms of period and radius m = 4*pi^2*r3/G*T^2 ---- mass in terms of velocity and radius m = v^2*r/G ''' validUnitTypes = [ [ 'time', 'length' ], [ 'velocity', 'length' ], [ 'time', 'velocity' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'orbital_mass\' requires specific measurement types (see help)' ) if 'time' in arguments: period = arguments[ 'time' ] if 'length' in arguments: bRadius = True radius = arguments[ 'length' ] else: bRadius = False velocity = arguments[ 'velocity' ] else: # velocity and radius radius = arguments[ 'length' ] velocity = arguments[ 'velocity' ] mass = divide( getProduct( [ velocity, velocity, radius ] ), getNewtonsConstant( ) ) return mass.convert( 'kilogram' ) if bRadius: # radius and period mass = divide( getProduct( [ 4, pi, pi, radius, radius, radius ] ), getProduct( [ getNewtonsConstant( ), period, period ] ) ) else: # velocity and period mass = divide( getProduct( [ velocity, velocity, velocity, period ] ), getProduct( [ 2, pi, getNewtonsConstant( ) ] ) ) return mass.convert( 'kilogram' )
def getIcosahedronSurfaceArea( n ): if not isinstance( n, RPNMeasurement ): return getIcosahedronVolume( RPNMeasurement( real( n ), 'meter' ) ) if n.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'icosahedron_area\' argument must be a length' ) return getProduct( [ 5, sqrt( 3 ), getPower( n, 2 ) ] ).convert( 'meter^2' )
def getIcosahedronVolume( n ): if not isinstance( n, RPNMeasurement ): return getIcosahedronVolume( RPNMeasurement( real( n ), 'meter' ) ) if n.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'icosahedron_volume\' argument must be a length' ) return getProduct( [ fdiv( 5, 12 ), fadd( 3, sqrt( 5 ) ), getPower( n, 3 ) ] ).convert( 'meter^3' )
def calculateOrbitalRadius( measurement1, measurement2 ): ''' To solve the radius of a circular orbit, we need Newton's gravitational constant and two of the following three items: G = Newton's gravitational constant m = planetary mass (i.e., mass of the thing being orbited) T = orbital period v = orbital velocity ---- radius in terms of period and mass r = cbrt( T^2*G*m/4*pi^2 ) ---- radius in terms of velocity and mass r = G*m/v^2 ---- radius in terms of velocity and period r = v*T/2*pi ''' validUnitTypes = [ [ 'mass', 'time' ], [ 'velocity', 'time' ], [ 'mass', 'velocity' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'orbital_radius\' requires specific measurement types (see help)' ) if 'mass' in arguments: mass = arguments[ 'mass' ] if 'time' in arguments: bPeriod = True period = arguments[ 'time' ] else: bPeriod = False velocity = arguments[ 'velocity' ] else: # period and velocity period = arguments[ 'time' ] velocity = arguments[ 'velocity' ] radius = divide( multiply( velocity, period ), fmul( 2, pi ) ) return radius.convert( 'meter' ) if bPeriod: # period and mass term = divide( getProduct( [ getPower( period, 2 ), getNewtonsConstant( ), mass ] ), fmul( 4, power( pi, 2 ) ) ) radius = getRoot( term, 3 ) else: # velocity and mass radius = divide( multiply( getNewtonsConstant( ), mass ), getPower( velocity, 2 ) ) return radius.convert( 'meter' )
def getDodecahedronSurfaceArea( n ): if not isinstance( n, RPNMeasurement ): return getDodecahedronSurfaceArea( RPNMeasurement( real( n ), 'meter' ) ) if n.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'dodecahedron_area\' argument must be a length' ) area = getProduct( [ 3, getRoot( add( 25, fmul( 10, sqrt( 5 ) ) ), 2 ), getPower( n, 2 ) ] ) return area.convert( 'meter^2' )
def getPrismSurfaceArea( n, k, h ): if real( n ) < 3: raise ValueError( 'the number of sides of the prism cannot be less than 3,' ) if not isinstance( k, RPNMeasurement ): return getPrismSurfaceArea( n, RPNMeasurement( real( k ), 'meter' ), h ) if not isinstance( h, RPNMeasurement ): return getPrismSurfaceArea( n, k, RPNMeasurement( real( h ), 'meter' ) ) if k.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'prism_area\' argument 2 must be a length' ) if h.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'prism_area\' argument 3 must be a length' ) result = add( getProduct( [ fdiv( n, 2 ), getPower( k, 2 ), cot( fdiv( pi, n ) ) ] ), getProduct( [ n, k, h ] ) ) return result.convert( 'meter^2' )
def calculateVelocity( measurement1, measurement2 ): validUnitTypes = [ [ 'length', 'time' ], [ 'acceleration', 'length' ], [ 'jerk', 'length' ], [ 'jounce', 'length' ], [ 'velocity', 'time' ], [ 'velocity', 'length' ], [ 'acceleration', 'time' ], [ 'jerk', 'time' ], [ 'jounce', 'time' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if 'velocity' in arguments: velocity = arguments[ 'velocity' ] elif 'length' in arguments: if 'time' in arguments: velocity = divide( arguments[ 'length' ], arguments[ 'time' ] ) elif 'acceleration' in arguments: acceleration = arguments[ 'acceleration' ] time = getRoot( multiply( divide( arguments[ 'length' ], acceleration ), 2 ), 2 ) velocity = multiply( acceleration, time ) elif 'jerk' in arguments: jerk = arguments[ 'jerk' ] time = getRoot( multiply( divide( arguments[ 'length' ], jerk ), 6 ), 3 ) velocity = getProduct( [ jerk, time, time, fdiv( 1, 2 ) ] ) elif 'jounce' in arguments: jounce = arguments[ 'jounce' ] time = getRoot( multiply( divide( arguments[ 'length' ], jounce ), 24 ), 4 ) velocity = getProduct( [ jounce, time, time, time, fdiv( 1, 6 ) ] ) elif 'acceleration' in arguments: velocity = divide( multiply( arguments[ 'acceleration' ], arguments[ 'time' ] ), 2 ) elif 'jerk' in arguments: velocity = divide( multiply( arguments[ 'jerk' ], getPower( arguments[ 'time' ], 2 ) ), 4 ) elif 'jounce' in arguments: velocity = divide( multiply( arguments[ 'jounce' ], getPower( arguments[ 'time' ], 3 ) ), 8 ) return velocity.convert( 'meter/second' )
def getTorusVolume( R, s ): if not isinstance( R, RPNMeasurement ): return getTorusVolume( RPNMeasurement( real( R ), 'meter' ), s ) if R.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'torus_volume\' argument 1 must be a length' ) if not isinstance( s, RPNMeasurement ): return getTorusVolume( R, RPNMeasurement( real( s ), 'meter' ) ) if s.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'torus_volume\' argument 2 must be a length' ) return getProduct( [ 2, power( pi, 2 ), R, getPower( s, 2 ) ] )
def getConeVolume( r, h ): if not isinstance( r, RPNMeasurement ): return getConeVolume( RPNMeasurement( real( r ), 'meter' ), h ) if r.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'cone_volume\' argument 1 must be a length' ) if not isinstance( h, RPNMeasurement ): return getConeVolume( r, RPNMeasurement( real( h ), 'meter' ) ) if h.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'cone_volume\' argument 2 must be a length' ) return getProduct( [ pi, getPower( r, 2 ), divide( h, 3 ) ] )
def calculateKineticEnergy( measurement1, measurement2 ): validUnitTypes = [ [ 'velocity', 'mass' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'kinetic_energy\' requires velocity and mass measurements' ) mass = arguments[ 'mass' ] velocity = arguments[ 'velocity' ] energy = getProduct( [ 0.5, mass, velocity, velocity ] ) return energy.convert( 'joule' )
def getConeSurfaceArea( r, h ): if not isinstance( r, RPNMeasurement ): return getConeSurfaceArea( RPNMeasurement( real( r ), 'meter' ), h ) if r.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'cone_area\' argument 1 must be a length' ) if not isinstance( h, RPNMeasurement ): return getConeSurfaceArea( r, RPNMeasurement( real( h ), 'meter' ) ) if h.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'cone_area\' argument 2 must be a length' ) hypotenuse = getRoot( add( getPower( r, 2 ), getPower( h, 2 ) ), 2 ) return getProduct( [ pi, r, add( r, hypotenuse ) ] )
def getAntiprismVolume( n, k ): if real( n ) < 3: raise ValueError( 'the number of sides of the prism cannot be less than 3,' ) if not isinstance( k, RPNMeasurement ): return getAntiprismVolume( n, RPNMeasurement( real( k ), 'meter' ) ) if k.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'antiprism_volume\' argument 2 must be a length' ) result = getProduct( [ fdiv( fprod( [ n, sqrt( fsub( fmul( 4, cos( cos( fdiv( pi, fmul( n, 2 ) ) ) ) ), 1 ) ), sin( fdiv( fmul( 3, pi ), fmul( 2, n ) ) ) ] ), fmul( 12, sin( sin( fdiv( pi, n ) ) ) ) ), sin( fdiv( fmul( 3, pi ), fmul( 2, n ) ) ), getPower( k, 3 ) ] ) return result.convert( 'meter^3' )
def getPrismVolume( n, k, h ): if real( n ) < 3: raise ValueError( 'the number of sides of the prism cannot be less than 3,' ) if not isinstance( k, RPNMeasurement ): return getPrismVolume( n, RPNMeasurement( real( k ), 'meter' ), h ) if not isinstance( h, RPNMeasurement ): return getPrismVolume( n, k, RPNMeasurement( real( h ), 'meter' ) ) if k.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'prism_volume\' argument 2 must be a length' ) if h.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'prism_volume\' argument 3 must be a length' ) return getProduct( [ fdiv( n, 4 ), h, getPower( k, 2 ), cot( fdiv( pi, n ) ) ] ).convert( 'meter^3' )
def getTriangleArea( a, b, c ): if not isinstance( a, RPNMeasurement ): return getTriangleArea( RPNMeasurement( real( a ), 'meter' ), b, c ) if a.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'triangle_area\' argument 1 must be a length' ) if not isinstance( b, RPNMeasurement ): return getTriangleArea( a, RPNMeasurement( real( b ), 'meter' ), c ) if b.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'triangle_area\' argument 2 must be a length' ) if not isinstance( c, RPNMeasurement ): return getTriangleArea( a, b, RPNMeasurement( real( c ), 'meter' ) ) if b.getDimensions( ) != { 'length' : 1 }: raise ValueError( '\'triangle_area\' argument 3 must be a length' ) if add( a, b ).isNotLarger( c ) or add( b, c ).isNotLarger( a ) or add( a, c ).isNotLarger( b ): raise ValueError( 'invalid triangle, the sum of any two sides must be longer than the third side' ) s = divide( getSum( [ a, b, c ] ), 2 ) # semi-perimeter return getRoot( getProduct( [ s, subtract( s, a ), subtract( s, b ), subtract( s, c ) ] ), 2 )
def calculateEscapeVelocity( mass, radius ): validateUnits( mass, 'mass' ) validateUnits( radius, 'length' ) velocity = getRoot( getProduct( [ 2, getNewtonsConstant( ), mass ] ).divide( radius ), 2 ) return velocity.convert( 'meter/second' )
def calculateEnergyEquivalence( mass ): validateUnits( mass, 'mass' ) energy = getProduct( [ mass, getSpeedOfLight( ), getSpeedOfLight( ) ] ) return energy.convert( 'joule' )
def calculateHorizonDistance( altitude, radius ): validateUnits( altitude, 'length' ) validateUnits( radius, 'length' ) distance = getRoot( getProduct( [ 2, radius, altitude ] ), 2 ) return distance.convert( 'meter' )
def calculateSchwarzchildRadius( mass ): validateUnits( mass, 'mass' ) radius = getProduct( [ 2, getNewtonsConstant( ), mass ] ).divide( getPower( getSpeedOfLight( ), 2 ) ) return radius.convert( 'meter' )