def calculateOrbitalRadiusOperator( 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 ), getConstant( 'newton_constant' ), mass ] ),
fmul( 4, power( pi, 2 ) ) )
radius = getRoot( term, 3 )
else:
# velocity and mass
radius = divide( multiply( getConstant( 'newton_constant' ), mass ), getPower( velocity, 2 ) )
return radius.convert( 'meter' )
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 ), getConstant( 'newton_constant' ), mass ] ),
fmul( 4, power( pi, 2 ) ) )
radius = getRoot( term, 3 )
else:
# velocity and mass
radius = divide( multiply( getConstant( 'newton_constant' ), mass ), getPower( velocity, 2 ) )
return radius.convert( 'meter' )
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( [ fdiv( 1, 2 ), arguments[ 'acceleration' ], time, time ] )
elif 'jerk' in arguments:
# jerk and time
distance = calculateDistance( getProduct( [ fdiv( 1, 2 ), arguments[ 'jerk' ], time ] ), time )
elif 'jounce' in arguments:
# jounce and time
distance = calculateDistance( getProduct( [ fdiv( 1, 2 ), arguments[ 'jounce' ], time ] ), time )
else:
# velocity and time
distance = multiply( arguments[ 'velocity' ], time )
return distance.convert( 'meter' )
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( [ fdiv( 1, 2 ), arguments[ 'acceleration' ], time, time ] )
elif 'jerk' in arguments:
# jerk and time
distance = calculateDistance( getProduct( [ fdiv( 1, 2 ), arguments[ 'jerk' ], time ] ), time )
elif 'jounce' in arguments:
# jounce and time
distance = calculateDistance( getProduct( [ fdiv( 1, 2 ), arguments[ 'jounce' ], time ] ), time )
else:
# velocity and time
distance = multiply( arguments[ 'velocity' ], time )
return distance.convert( 'meter' )
def getTetrahedronSurfaceArea( n ):
if not isinstance( n, RPNMeasurement ):
return getTetrahedronSurfaceArea( RPNMeasurement( real( n ), 'meter' ) )
if n.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'tetrahedron_area\' argument must be a length' )
return multiply( sqrt( 3 ), getPower( n, 2 ) )
def getDodecahedronVolume( n ):
if not isinstance( n, RPNMeasurement ):
return getDodecahedronVolume( RPNMeasurement( real( n ), 'meter' ) )
if n.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'dodecahedron_volume\' argument must be a length' )
return divide( multiply( fadd( 15, fmul( 7, sqrt( 5 ) ) ), getPower( n, 3 ) ), 4 ).convert( 'meter^3' )
def getOctahedronVolume( n ):
if not isinstance( n, RPNMeasurement ):
return getOctahedronVolume( RPNMeasurement( real( n ), 'meter' ) )
if n.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'octahedron_volume\' argument must be a length' )
return divide( multiply( sqrt( 2 ), getPower( n, 3 ) ), 3 )
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( getConstant( 'newton_constant' ), mass ), radius ), 2 )
else:
# mass and period
term = divide( getProduct( [ period, period, getConstant( 'newton_constant' ), mass ] ),
getProduct( [ 4, pi, pi ] ) )
velocity = divide( getProduct( [ 2, pi, getRoot( term, 3 ) ] ), period )
return velocity.convert( 'meter/second' )
def calculateOrbitalVelocityOperator( 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( getConstant( 'newton_constant' ), mass ), radius ), 2 )
else:
# mass and period
term = divide( getProduct( [ period, period, getConstant( 'newton_constant' ), mass ] ),
getProduct( [ 4, pi, pi ] ) )
velocity = divide( getProduct( [ 2, pi, getRoot( term, 3 ) ] ), period )
return velocity.convert( 'meter/second' )
def calculateOrbitalPeriodOperator( 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( getConstant( 'newton_constant' ), mass ) )
period = getProduct( [ 2, pi, getRoot( term, 2 ) ] )
else:
# velocity and mass
period = divide( getProduct( [ 2, pi, getConstant( 'newton_constant' ), mass ] ),
getPower( velocity, 3 ) )
return period.convert( '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( getConstant( 'newton_constant' ), mass ) )
period = getProduct( [ 2, pi, getRoot( term, 2 ) ] )
else:
# velocity and mass
period = divide( getProduct( [ 2, pi, getConstant( 'newton_constant' ), mass ] ),
getPower( velocity, 3 ) )
return period.convert( 'second' )
def calculateAccelerationOperator( measurement1, measurement2 ):
validUnitTypes = [
[ 'velocity', 'length' ],
[ 'velocity', 'time' ],
[ 'length', 'time' ],
[ 'acceleration', 'time' ],
[ 'acceleration', 'length' ],
]
arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes )
if 'acceleration' in arguments:
acceleration = arguments[ 'acceleration' ]
elif 'velocity' in arguments:
if 'length' in arguments:
acceleration = divide( getPower( arguments[ 'velocity' ], 2 ), multiply( arguments[ 'length' ], 2 ) )
else:
acceleration = divide( arguments[ 'velocity' ], arguments[ 'time' ] )
elif 'length' in arguments and 'time' in arguments:
acceleration = multiply( 2, divide( arguments[ 'length' ], getPower( arguments[ 'time' ], 2 ) ) )
return acceleration.convert( 'meter/second^2' )
def getRegularPolygonArea( n, k ):
if real( n ) < 3:
raise ValueError( 'the number of sides of the polygon cannot be less than 3,' )
if not isinstance( k, RPNMeasurement ):
return getRegularPolygonArea( n, RPNMeasurement( real( k ), 'meter' ) )
dimensions = k.getDimensions( )
if dimensions != { 'length' : 1 }:
raise ValueError( '\'polygon_area\' argument 2 must be a length' )
return multiply( fdiv( n, fmul( 4, tan( fdiv( pi, n ) ) ) ), getPower( k, 2 ) ).convert( 'meter^2' )
def calculateAcceleration( measurement1, measurement2 ):
validUnitTypes = [
[ 'velocity', 'length' ],
[ 'velocity', 'time' ],
[ 'length', 'time' ],
[ 'acceleration', 'time' ],
[ 'acceleration', 'length' ],
]
arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes )
if 'acceleration' in arguments:
acceleration = arguments[ 'acceleration' ]
elif 'velocity' in arguments:
if 'length' in arguments:
acceleration = divide( getPower( arguments[ 'velocity' ], 2 ), multiply( arguments[ 'length' ], 2 ) )
else:
acceleration = divide( arguments[ 'velocity' ], arguments[ 'time' ] )
elif 'length' in arguments and 'time' in arguments:
acceleration = multiply( 2, divide( arguments[ 'length' ], getPower( arguments[ 'time' ], 2 ) ) )
return acceleration.convert( 'meter/second^2' )
def calculateSurfaceGravity( measurement1, measurement2 ):
validUnitTypes = [
[ 'mass', 'density' ],
[ 'mass', 'length' ],
[ 'mass', 'volume' ],
[ 'density', 'length' ],
[ 'density', 'volume' ],
]
arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes )
if not arguments:
raise ValueError( '\'surface_gravity\' requires length and mass measurements' )
if 'mass' in arguments:
mass = arguments[ 'mass' ]
if 'length' in arguments:
length = arguments[ 'length' ]
elif 'density' in arguments:
volume = divide( mass, arguments[ 'density' ] )
length = getKSphereRadius( volume, 3 )
else:
length = getKSphereRadius( arguments[ 'volume' ], 3 )
elif 'volume' in arguments:
# density, volume
volume = arguments[ 'volume' ]
mass = multiply( arguments[ 'density' ], volume )
length = getKSphereRadius( volume, 3 )
else:
# density, length
length = arguments[ 'length' ]
volume = getPower( length, 3 )
mass = multiply( arguments[ 'density' ], volume )
gravity = multiply( divide( mass, getPower( length, 2 ) ), getConstant( 'newton_constant' ) )
return gravity.convert( 'meters/seconds^2' )
def calculateSurfaceGravityOperator( measurement1, measurement2 ):
validUnitTypes = [
[ 'mass', 'density' ],
[ 'mass', 'length' ],
[ 'mass', 'volume' ],
[ 'density', 'length' ],
[ 'density', 'volume' ],
]
arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes )
if not arguments:
raise ValueError( '\'surface_gravity\' requires length and mass measurements' )
if 'mass' in arguments:
mass = arguments[ 'mass' ]
if 'length' in arguments:
length = arguments[ 'length' ]
elif 'density' in arguments:
volume = divide( mass, arguments[ 'density' ] )
length = getKSphereRadius( volume, 3 )
else:
length = getKSphereRadius( arguments[ 'volume' ], 3 )
elif 'volume' in arguments:
# density, volume
volume = arguments[ 'volume' ]
mass = multiply( arguments[ 'density' ], volume )
length = getKSphereRadius( volume, 3 )
else:
# density, length
length = arguments[ 'length' ]
volume = getPower( length, 3 )
mass = multiply( arguments[ 'density' ], volume )
gravity = multiply( divide( mass, getPower( length, 2 ) ), getConstant( 'newton_constant' ) )
return gravity.convert( 'meters/seconds^2' )
def getProduct( n ):
if isinstance( n, RPNGenerator ):
return getProduct( list( n ) )
if isinstance( n[ 0 ], ( list, RPNGenerator ) ):
return [ getProduct( arg ) for arg in n ]
if not n:
return 0
if len( n ) == 1:
return n[ 0 ]
hasUnits = False
for item in n:
if isinstance( item, RPNMeasurement ):
hasUnits = True
break
if hasUnits:
result = RPNMeasurement( 1 )
for item in n:
if isinstance( item, list ):
return [ getProduct( arg ) for arg in item ]
result = multiply( result, item )
return result
if not n:
return 0
if isinstance( n[ 0 ], list ):
return [ getProduct( item ) for item in n ]
return fprod( n )
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 calculateVelocityOperator( 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 getDodecahedronVolumeOperator(n):
return divide(multiply(fadd(15, fmul(7, sqrt(5))), getPower(n, 3)),
4).convert('meter^3')
def getOctahedronVolumeOperator(n):
return divide(multiply(sqrt(2), getPower(n, 3)), 3)
def getRegularPolygonArea(n, k):
return multiply(fdiv(n, fmul(4, tan(fdiv(pi, n)))),
getPower(k, 2)).convert('meter^2')
def getTetrahedronSurfaceAreaOperator(n):
return multiply(sqrt(3), getPower(n, 2))
def getCumulativeListProducts( args ):
total = 1
for i in args:
total = multiply( total, i )
yield total
def calculateMassEquivalence( energy ):
energy.validateUnits( 'energy' )
mass = divide( energy, multiply( getConstant( 'speed_of_light' ), getConstant( 'speed_of_light' ) ) )
return mass.convert( 'kilogram' )
def calculateMassEquivalenceOperator( energy ):
energy.validateUnits( 'energy' )
mass = divide( energy, multiply( getConstant( 'speed_of_light' ), getConstant( 'speed_of_light' ) ) )
return mass.convert( 'kilogram' )
