def OLDgetPartitionNumber( n ):
    if n < 0:
        return 0

    if n < 2:
        return 1

    result = mpmathify( 0 )

    for k in arange( 1, n + 1 ):
        #n1 = n - k * ( 3 * k - 1 ) / 2
        n1 = fsub( n, fdiv( fmul( k, fsub( fmul( 3, k ), 1 ) ), 2 ) )
        #n2 = n - k * ( 3 * k + 1 ) / 2
        n2 = fsub( n, fdiv( fmul( k, fadd( fmul( 3, k ), 1 ) ), 2 ) )

        result = fadd( result, fmul( power( -1, fadd( k, 1 ) ), fadd( getPartitionNumber( n1 ), getPartitionNumber( n2 ) ) ) )

        if n1 <= 0:
            break

    #old = NOT_QUITE_AS_OLDgetPartitionNumber( n )
    #
    #if ( old != result ):
    #    raise ValueError( "It's broke." )

    return result
Exemple #2
0
def getSkyLocation( n, k ):
    if not isinstance( n, ephem.Body ) or not isinstance( k, RPNDateTime ):
        raise ValueError( '\'sky_location\' expects an astronomical object and a date-time' )

    n.compute( k.to( 'utc' ).format( ) )

    return [ fdiv( fmul( mpmathify( n.ra ), 180 ), pi ), fdiv( fmul( mpmathify( n.dec ), 180 ), pi ) ]
Exemple #3
0
def oldGetPartitionNumber(n):
    if n < 2:
        return 1

    result = mpmathify(0)

    for k in arange(1, n + 1):
        #n1 = n - k * ( 3 * k - 1 ) / 2
        sub1 = fsub(n, fdiv(fmul(k, fsub(fmul(3, k), 1)), 2))
        #n2 = n - k * ( 3 * k + 1 ) / 2
        sub2 = fsub(n, fdiv(fmul(k, fadd(fmul(3, k), 1)), 2))

        result = fadd(
            result,
            fmul(power(-1, fadd(k, 1)),
                 fadd(getPartitionNumber(sub1), getPartitionNumber(sub2))))

        if sub1 <= 0:
            break

    #old = NOT_QUITE_AS_OLDgetPartitionNumber( n )
    #
    #if ( old != result ):
    #    raise ValueError( "It's broke." )

    return result
Exemple #4
0
def getRobbinsConstant( ):
    robbins = fsub( fsub( fadd( 4, fmul( 17, sqrt( 2 ) ) ), fmul( 6, sqrt( 3 ) ) ), fmul( 7, pi ) )
    robbins = fdiv( robbins, 105 )
    robbins = fadd( robbins, fdiv( log( fadd( 1, sqrt( 2 ) ) ), 5 ) )
    robbins = fadd( robbins, fdiv( fmul( 2, log( fadd( 2, sqrt( 3 ) ) ) ), 5 ) )

    return robbins
Exemple #5
0
    def vector(self):

        return Vector([
            mpmath.fdiv(self._params[0], self._params[3]),
            mpmath.fdiv(self._params[1], self._params[3]),
            mpmath.fdiv(self._params[2], self._params[3])
        ])
Exemple #6
0
def getRobbinsConstant( ):
    robbins = fsub( fsub( fadd( 4, fmul( 17, sqrt( 2 ) ) ), fmul( 6, sqrt( 3 ) ) ), fmul( 7, pi ) )
    robbins = fdiv( robbins, 105 )
    robbins = fadd( robbins, fdiv( log( fadd( 1, sqrt( 2 ) ) ), 5 ) )
    robbins = fadd( robbins, fdiv( fmul( 2, log( fadd( 2, sqrt( 3 ) ) ) ), 5 ) )

    return robbins
Exemple #7
0
def extrapolateTransitiveConversions( op1, op2, unitTypeTable, unitType, unitConversionMatrix ):
    newConversions = { }

    for op3 in unitTypeTable[ unitType ]:
        # we can ignore duplicate operators
        if op3 in [ op1, op2 ]:
            continue

        # we can shortcut if the types are not compatible
        if unitOperators[ op3 ].unitType != unitOperators[ op1 ].unitType:
            continue

        conversion = unitConversionMatrix[ ( op1, op2 ) ]

        if ( op1, op3 ) not in unitConversionMatrix and \
           ( op2, op3 ) in unitConversionMatrix:
            # print( 'transitive: ', ( op2, op3 ),
            #        unitConversionMatrix[ ( op2, op3 ) ] )
            newConversion = fmul( conversion, unitConversionMatrix[ ( op2, op3 ) ] )
            # print( ( op1, op3 ), newConversion )
            newConversions[ ( op1, op3 ) ] = newConversion
            # print( ( op3, op1 ), fdiv( 1, newConversion ) )
            newConversions[ ( op3, op1 ) ] = fdiv( 1, newConversion )
        elif ( op2, op3 ) not in unitConversionMatrix and \
             ( op1, op3 ) in unitConversionMatrix:
            # print( 'transitive: ', ( op1, op3 ),
            #        unitConversionMatrix[ ( op1, op3 ) ] )
            newConversion = fdiv( unitConversionMatrix[ ( op1, op3 ) ], conversion )
            # print( ( op2, op3 ), newConversion )
            newConversions[ ( op2, op3 ) ] = newConversion
            # print( ( op3, op2 ), fdiv( 1, newConversion ) )
            newConversions[ ( op3, op2 ) ] = fdiv( 1, newConversion )

    return newConversions
Exemple #8
0
def getNthKFibonacciNumber( n, k ):
    if real( n ) < 0:
        raise ValueError( 'non-negative argument expected' )

    if real( k ) < 2:
        raise ValueError( 'argument <= 2 expected' )

    if n < k - 1:
        return 0

    nth = int( n ) + 4

    precision = int( fdiv( fmul( n, k ), 8 ) )

    if ( mp.dps < precision ):
        mp.dps = precision

    poly = [ 1 ]
    poly.extend( [ -1 ] * int( k ) )

    roots = polyroots( poly )
    nthPoly = getNthFibonacciPolynomial( k )

    result = 0
    exponent = fsum( [ nth, fneg( k ), -2 ] )

    for i in range( 0, int( k ) ):
        result += fdiv( power( roots[ i ], exponent ), polyval( nthPoly, roots[ i ] ) )

    return floor( fadd( re( result ), fdiv( 1, 2 ) ) )
Exemple #9
0
def getNthDecagonalCenteredSquareNumberOperator(n):
    sqrt10 = sqrt(10)

    dps = 7 * int(n)

    if mp.dps < dps:
        mp.dps = dps

    return nint(
        floor(
            fsum([
                fdiv(1, 8),
                fmul(fdiv(7, 16),
                     power(fsub(721, fmul(228, sqrt10)), fsub(n, 1))),
                fmul(
                    fmul(fdiv(1, 8),
                         power(fsub(721, fmul(228, sqrt10)), fsub(n, 1))),
                    sqrt10),
                fmul(
                    fmul(fdiv(1, 8),
                         power(fadd(721, fmul(228, sqrt10)), fsub(n, 1))),
                    sqrt10),
                fmul(fdiv(7, 16),
                     power(fadd(721, fmul(228, sqrt10)), fsub(n, 1)))
            ])))
Exemple #10
0
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 verige(num, denominator_limit):
    Z = num
    C = []
    P = []
    Q = []

    C.append(int(mp.floor(num)))
    Z = mp.fdiv(1, mp.frac(Z))
    C.append(int(mp.floor(Z)))

    P.append(C[0])
    P.append(C[0] * C[1] + 1)
    Q.append(1)
    Q.append(C[1])

    for k in range(2, 1000000):
        Z = mp.fdiv(1, mp.frac(Z))
        C.append(int(mp.floor(Z)))

        if Q[-1] > denominator_limit:
            break

        P.append(C[k] * P[k - 1] + P[k - 2])
        Q.append(C[k] * Q[k - 1] + Q[k - 2])

    return C, P, Q
Exemple #12
0
def cont_frac_expansion_sqrt(n):
	"""
	n is NOT square
	e.g. 2 --> (1,2) (2 repeats)
	"""
	if is_square(n):
		return 0
	seq = []
	r = mp.sqrt(n,prec=1000) # DOESNT MATTER?
	a = floor(r)
	fls = [r]
	seq.append(int(a))
	r = mp.fdiv(1.,mp.fsub(r,a,prec=1000),prec=1000)
	a = floor(r)
	fls.append(r)
	seq.append(int(a))
	r = mp.fdiv(1.,mp.fsub(r,a,prec=1000),prec=1000) #THESE TWO MATTER!!!
	a = floor(r)
	fls.append(r)
	seq.append(int(a))
	while not close(r, fls[1]):
		r = mp.fdiv(1.,mp.fsub(r,a,prec=1000),prec=1000) #THESE TWO MATTER!!!
		a = floor(r)
		fls.append(r)
		seq.append(int(a))
	# print seq
	seq.pop()
	return seq
Exemple #13
0
def getInvertedBits( n ):
    value = real_int( n )

    # determine how many groups of bits we will be looking at
    if value == 0:
        groupings = 1
    else:
        groupings = int( fadd( floor( fdiv( ( log( value, 2 ) ), g.bitwiseGroupSize ) ), 1 ) )

    placeValue = mpmathify( 1 << g.bitwiseGroupSize )
    multiplier = mpmathify( 1 )
    remaining = value

    result = mpmathify( 0 )

    for i in range( 0, groupings ):
        # Let's let Python do the actual inverting
        group = fmod( ~int( fmod( remaining, placeValue ) ), placeValue )

        result += fmul( group, multiplier )

        remaining = floor( fdiv( remaining, placeValue ) )
        multiplier = fmul( multiplier, placeValue )

    return result
Exemple #14
0
def getEclipseTotality( body1, body2, location, date ):
    '''Returns the angular size of an astronomical object in radians.'''
    if isinstance( location, str ):
        location = getLocation( location )

    if not isinstance( body1, RPNAstronomicalObject ) or not isinstance( body2, RPNAstronomicalObject ) and \
       not isinstance( location, RPNLocation ) or not isinstance( date, RPNDateTime ):
        raise ValueError( 'expected two astronomical objects, a location and a date-time' )

    separation = body1.getAngularSeparation( body2, location, date ).value

    radius1 = body1.getAngularSize( ).value
    radius2 = body2.getAngularSize( ).value

    if separation > fadd( radius1, radius2 ):
        return 0

    distance1 = body1.getDistanceFromEarth( date )
    distance2 = body2.getDistanceFromEarth( date )

    area1 = fmul( pi, power( radius1, 2 ) )
    area2 = fmul( pi, power( radius2, 2 ) )

    area_of_intersection = fadd( getCircleIntersectionTerm( radius1, radius2, separation ),
                                 getCircleIntersectionTerm( radius2, radius1, separation ) )

    if distance1 > distance2:
        result = fdiv( area_of_intersection, area1 )
    else:
        result = fdiv( area_of_intersection, area2 )

    if result > 1:
        return 1
    else:
        return result
Exemple #15
0
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' )
Exemple #16
0
 def RD_new(self, i):
     RD_curr = self.RD_j()[i][1]
     RD_prime = mp.sqrt(
         mp.fdiv(1,
                 mp.fdiv(1, RD_curr**2) + mp.fdiv(1,
                                                  self.d_sq(i)**2)))
     return RD_prime
Exemple #17
0
def extrapolateTransitiveConversions(op1, op2, unitTypeTable, unitType,
                                     unitConversionMatrix):
    newConversions = {}

    for op3 in unitTypeTable[unitType]:
        # we can ignore duplicate operators
        if op3 in [op1, op2]:
            continue

        conversion = unitConversionMatrix[(op1, op2)]

        if ( op1, op3 ) not in unitConversionMatrix and \
           ( op2, op3 ) in unitConversionMatrix:
            # print( 'transitive: ', ( op2, op3 ),
            #        unitConversionMatrix[ ( op2, op3 ) ] )
            newConversion = fmul(conversion, unitConversionMatrix[(op2, op3)])
            # print( ( op1, op3 ), newConversion )
            newConversions[(op1, op3)] = newConversion
            # print( ( op3, op1 ), fdiv( 1, newConversion ) )
            newConversions[(op3, op1)] = fdiv(1, newConversion)
        elif ( op2, op3 ) not in unitConversionMatrix and \
             ( op1, op3 ) in unitConversionMatrix:
            # print( 'transitive: ', ( op1, op3 ),
            #        unitConversionMatrix[ ( op1, op3 ) ] )
            newConversion = fdiv(unitConversionMatrix[(op1, op3)], conversion)
            # print( ( op2, op3 ), newConversion )
            newConversions[(op2, op3)] = newConversion
            # print( ( op3, op2 ), fdiv( 1, newConversion ) )
            newConversions[(op3, op2)] = fdiv(1, newConversion)

    return newConversions
Exemple #18
0
def findCenteredPolygonalNumber( n, k ):
    if real_int( k ) < 3:
        raise ValueError( 'the number of sides of the polygon cannot be less than 3,' )

    s = fdiv( k, 2 )

    return nint( fdiv( fadd( sqrt( s ),
                       sqrt( fsum( [ fmul( 4, real( n ) ), s, -4 ] ) ) ), fmul( 2, sqrt( s ) ) ) )
Exemple #19
0
def getLocationInfo( location ):
    if isinstance( location, str ):
        location = getLocation( location )
    elif not isinstance( location. RPNLocation ):
        raise ValueError( 'location name or location object expected' )

    return [ fdiv( fmul( mpmathify( location.observer.lat ), 180 ), pi ),
             fdiv( fmul( mpmathify( location.observer.long ), 180 ), pi ) ]
Exemple #20
0
def getNthMotzkinNumber( n ):
    result = 0

    for j in arange( 0, floor( fdiv( real( n ), 3 ) ) + 1 ):
        result = fadd( result, fprod( [ power( -1, j ), binomial( fadd( n, 1 ), j ),
                                      binomial( fsub( fmul( 2, n ), fmul( 3, j ) ), n ) ] ) )

    return fdiv( result, fadd( n, 1 ) )
Exemple #21
0
def getSkyLocation( n, k ):
    '''Returns the location of an astronomical object in the sky in terms of right ascension and declination.'''
    if not isinstance( n, ephem.Body ) or not isinstance( k, RPNDateTime ):
        raise ValueError( '\'sky_location\' expects an astronomical object and a date-time' )

    n.compute( k.to( 'utc' ).format( ) )

    return [ fdiv( fmul( mpmathify( n.ra ), 180 ), pi ), fdiv( fmul( mpmathify( n.dec ), 180 ), pi ) ]
Exemple #22
0
def char_fun(u, mu, sigma, lemu, lemd, etau, etad, T, S0):
    lem = lemu + lemd  #Define net arrival rate for up and down jumps
    p = lemu / lem  #Conditional probability of an up jump given that a jump is happening
    charac_exp = -0.5 * (sigma**2) * (u**2) + mp.mpc(0, 1) * mu * u + mp.mpc(
        0, 1) * u * lem * (mp.fdiv(p, etau - mp.mpc(0, 1) * u) - mp.fdiv(
            1 - p, etad + mp.mpc(0, 1) * u))  #Characteristic expression
    phiT = mp.exp(mp.mpc(0, 1) * u * mp.log(S0)) * mp.exp(
        T * charac_exp)  #Characteristic function
    return phiT
Exemple #23
0
    def point(self):
        if mpmath.almosteq(self._params[3], mpmath.mpf(1)):
            return Point([self._params[0], self._params[1], self._params[2]])

        return Point([
            mpmath.fdiv(self._params[0], self._params[3]),
            mpmath.fdiv(self._params[1], self._params[3]),
            mpmath.fdiv(self._params[2], self._params[3])
        ])
    def divide(self, other):
        if isinstance(other, RPNMeasurement):
            factor, newUnits = self.units.combineUnits(other.units.inverted())
            newUnits = RPNMeasurement(1, newUnits).simplifyUnits().units

            return RPNMeasurement(fmul(fdiv(self.value, other.value), factor),
                                  newUnits).normalizeUnits()

        return RPNMeasurement(fdiv(self.value, other),
                              self.units).normalizeUnits()
Exemple #25
0
def getLocationInfoOperator(location):
    if isinstance(location, str):
        location = getLocation(location)
    elif not isinstance(location, RPNLocation):
        raise ValueError('location name or location object expected')

    return [
        fdiv(fmul(mpmathify(location.observer.lat), 180), pi),
        fdiv(fmul(mpmathify(location.observer.long), 180), pi)
    ]
Exemple #26
0
def getNthNonagonalTriangularNumber( n ):
    a = fmul( 3, sqrt( 7 ) )
    b = fadd( 8, a )
    c = fsub( 8, a )

    return nint( fsum( [ fdiv( 5, 14 ),
                         fmul( fdiv( 9, 28 ), fadd( power( b, real_int( n ) ), power( c, n ) ) ),
                         fprod( [ fdiv( 3, 28 ),
                                  sqrt( 7 ),
                                  fsub( power( b, n ), power( c, n ) ) ] ) ] ) )
Exemple #27
0
def expandDataUnits( ):
    # expand data measurements for all prefixes
    newConversions = { }

    for dataUnit in dataUnits:
        unitInfo = unitOperators[ dataUnit ]

        for prefix in dataPrefixes:
            newName = prefix[ 0 ] + dataUnit

            # constuct unit operator info
            helpText = '\n\'Using the standard SI prefixes, ' + newName + '\' is the equivalent\nof ' + \
                       '{:,}'.format( 10 ** prefix[ 2 ] ) + ' times the value of \'' + dataUnit + \
                       '\'.\n\nPlease see the help entry for \'' + dataUnit + '\' for more information.'

            if unitInfo.abbrev:
                newAbbrev = prefix[ 0 ] + unitInfo.abbrev
            else:
                newAbbrev = ''

            unitOperators[ newName ] = \
                RPNUnitInfo( unitInfo.unitType, prefix[ 0 ] + unitInfo.plural,
                             newAbbrev, [ ], unitInfo.categories, helpText, True )

            # create new conversions
            newConversion = power( 10, mpmathify( prefix[ 2 ] ) )
            newConversions[ ( newName, dataUnit ) ] = newConversion
            newConversion = fdiv( 1, newConversion )
            newConversions[ ( dataUnit, newName ) ] = newConversion

        for prefix in binaryPrefixes:
            newName = prefix[ 0 ] + dataUnit

            # constuct unit operator info
            helpText = '\n\'Using the binary data size prefixes, ' + newName + '\' is the equivalent\nof 2^' + \
                       str( prefix[ 2 ] ) + ' times the value of \'' + dataUnit + \
                       '\'.\n\nPlease see the help entry for \'' + dataUnit + '\' for more information.'

            if unitInfo.abbrev:
                newAbbrev = prefix[ 0 ] + unitInfo.abbrev
            else:
                newAbbrev = ''

            unitOperators[ newName ] = \
                RPNUnitInfo( unitInfo.unitType, prefix[ 0 ] + unitInfo.plural,
                             newAbbrev, [ ], unitInfo.categories, helpText, True )

            # create new conversions
            newConversion = power( 2, mpmathify( prefix[ 2 ] ) )
            newConversions[ ( newName, dataUnit ) ] = newConversion
            newConversion = fdiv( 1, newConversion )
            newConversions[ ( dataUnit, newName ) ] = newConversion

    return newConversions
Exemple #28
0
    def getAngularSize( self, location=None, date=None ):
        if location and date:
            if isinstance( location, str ):
                location = getLocation( location )

            location.observer.date = date.to( 'utc' ).format( )
            self.object.compute( location.observer )

        # I have no idea why size seems to return the value in arcseconds... that
        # goes against the pyephem documentation that it always uses radians for angles.
        return RPNMeasurement( mpmathify( fdiv( fmul( fdiv( self.object.size, 3600 ), pi ), 180 ) ), 'radian' )
Exemple #29
0
    def getAngularSize( self, location=None, date=None ):
        if location and date:
            if isinstance( location, str ):
                location = getLocation( location )

            location.observer.date = date.to( 'utc' ).format( )
            self.object.compute( location.observer )

        # I have no idea why size seems to return the value in arcseconds... that
        # goes against the pyephem documentation that it always uses radians for angles.
        return RPNMeasurement( mpmathify( fdiv( fmul( fdiv( self.object.size, 3600 ), pi ), 180 ) ), 'radian' )
Exemple #30
0
def main():
    parser = argparse.ArgumentParser(description='Design Serial Diode')
    parser.add_argument('Vs', type=float, help='Voltage supply')
    parser.add_argument('Id',
                        type=float,
                        help='Desired current over the diode in Amps')
    parser.add_argument(
        'Is',
        type=float,
        nargs='?',
        default=1e-12,
        help='Diode Saturation current in Amps (default = 1e-12)')
    parser.add_argument('N',
                        type=float,
                        nargs='?',
                        default=1,
                        help='Emission Coefficient (default = 1)')
    parser.add_argument('--Vt',
                        type=float,
                        default=0.026,
                        help='Thermal Voltage in Volts (default = 0.026)')
    parser.add_argument('-g',
                        '--graph',
                        action='store_true',
                        help='Draw a graph')
    parser.add_argument('-v',
                        '--verbose',
                        action='store_true',
                        help='Print debug')
    args = parser.parse_args()

    Vs = args.Vs
    Id = args.Id
    Is = args.Is
    N = args.N
    Vt = args.Vt
    nVt = N * Vt

    if args.verbose:
        logging.basicConfig(format='%(levelname)s|%(message)s',
                            level=logging.INFO)
    logging.info(f'Vs: {Vs}, Id: {Id}, Is: {Is}, N: {N}, Vt: {Vt}')

    Vd = fmul(log(fadd(fdiv(Id, Is), mpf(1))), nVt)
    VR = fsub(Vs, Vd)
    IR = Id
    R = fdiv(VR, IR)
    print("VR: {}, IR: {}, R: {}".format(VR, IR, R))
    print("Vd: {}, Id: {}, Rd: {}".format(Vd, Id, fdiv(Vd, Id)))
    if args.graph:
        plot([
            lambda x: fsub(Vs, fmul(x, R)),
            lambda x: fmul(nVt, log(fadd(fdiv(x, Is), 1)))
        ], [0, fdiv(Vs, R)], [0, Vs])
Exemple #31
0
def expandDataUnits():
    # expand data measurements for all prefixes
    newConversions = {}

    for dataUnit in dataUnits:
        unitInfo = unitOperators[dataUnit]

        for prefix in dataPrefixes:
            newName = prefix[0] + dataUnit

            # constuct unit operator info
            helpText = '\n\'Using the standard SI prefixes, ' + newName + '\' is the equivalent\nof ' + \
                       '{:,}'.format( 10 ** prefix[ 2 ] ) + ' times the value of \'' + dataUnit + \
                       '\'.\n\nPlease see the help entry for \'' + dataUnit + '\' for more information.'

            if unitInfo.abbrev:
                newAbbrev = prefix[0] + unitInfo.abbrev
            else:
                newAbbrev = ''

            unitOperators[ newName ] = \
                RPNUnitInfo( unitInfo.unitType, prefix[ 0 ] + unitInfo.plural,
                             newAbbrev, [ ], unitInfo.categories, helpText, True )

            # create new conversions
            newConversion = power(10, mpmathify(prefix[2]))
            newConversions[(newName, dataUnit)] = newConversion
            newConversion = fdiv(1, newConversion)
            newConversions[(dataUnit, newName)] = newConversion

        for prefix in binaryPrefixes:
            newName = prefix[0] + dataUnit

            # constuct unit operator info
            helpText = '\n\'Using the binary data size prefixes, ' + newName + '\' is the equivalent\nof 2^' + \
                       str( prefix[ 2 ] ) + ' times the value of \'' + dataUnit + \
                       '\'.\n\nPlease see the help entry for \'' + dataUnit + '\' for more information.'

            if unitInfo.abbrev:
                newAbbrev = prefix[0] + unitInfo.abbrev
            else:
                newAbbrev = ''

            unitOperators[ newName ] = \
                RPNUnitInfo( unitInfo.unitType, prefix[ 0 ] + unitInfo.plural,
                             newAbbrev, [ ], unitInfo.categories, helpText, True )

            # create new conversions
            newConversion = power(2, mpmathify(prefix[2]))
            newConversions[(newName, dataUnit)] = newConversion
            newConversion = fdiv(1, newConversion)
            newConversions[(dataUnit, newName)] = newConversion

    return newConversions
Exemple #32
0
def getNthStern( n ):
    """Return the nth number of Stern's diatomic series recursively"""
    if real_int( n ) < 0:
        raise ValueError( 'non-negative, real integer expected' )

    if n in [ 0, 1 ]:
        return n
    elif n % 2 == 0: # even
        return getNthStern( floor( fdiv( n, 2 ) ) )
    else:
        return fadd( getNthStern( floor( fdiv( fsub( n, 1 ), 2 ) ) ),
                     getNthStern( floor( fdiv( fadd( n, 1 ), 2 ) ) ) )
Exemple #33
0
def getAntiprismSurfaceArea( 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 getAntiprismSurfaceArea( n, RPNMeasurement( real( k ), 'meter' ) )

    if k.getDimensions( ) != { 'length' : 1 }:
        raise ValueError( '\'antiprism_area\' argument 2 must be a length' )

    result = getProduct( [ fdiv( n, 2 ), fadd( cot( fdiv( pi, n ) ), sqrt( 3 ) ), getPower( k, 2 ) ] )
    return result.convert( 'meter^2' )
Exemple #34
0
def _crt( a, b, m, n ):
    d = getGCD( m, n )

    if fmod( fsub( a, b ), d ) != 0:
        return None

    x = floor( fdiv( m, d ) )
    y = floor( fdiv( n, d ) )
    z = floor( fdiv( fmul( m, n ), d ) )
    p, q, r = getExtendedGCD( x, y )

    return fmod( fadd( fprod( [ b, p, x ] ), fprod( [ a, q, y ] ) ), z )
Exemple #35
0
def isFriendly( n ):
    first = True

    abundance = 0

    for i in n:
        if first:
            abundance = fdiv( getSigma( i ), i )
            first = False
        elif fdiv( getSigma( i ), i ) != abundance:
            return 0

    return 1
Exemple #36
0
def getNthDecagonalCenteredSquareNumber( n ):
    sqrt10 = sqrt( 10 )

    dps = 7 * int( real_int( n ) )

    if mp.dps < dps:
        mp.dps = dps

    return nint( floor( fsum( [ fdiv( 1, 8 ),
                              fmul( fdiv( 7, 16 ), power( fsub( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ),
                              fmul( fmul( fdiv( 1, 8 ), power( fsub( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ), sqrt10 ),
                              fmul( fmul( fdiv( 1, 8 ), power( fadd( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ), sqrt10 ),
                              fmul( fdiv( 7, 16 ), power( fadd( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ) ] ) ) )
Exemple #37
0
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' )
Exemple #38
0
def getNthMotzkinNumber( n ):
    '''
    http://oeis.org/A001006

    a(n) = sum((-1)^j*binomial(n+1, j)*binomial(2n-3j, n), j=0..floor(n/3))/(n+1)
    '''
    result = 0

    for j in arange( 0, floor( fdiv( real( n ), 3 ) ) + 1 ):
        result = fadd( result, fprod( [ power( -1, j ), binomial( fadd( n, 1 ), j ),
                                      binomial( fsub( fmul( 2, n ), fmul( 3, j ) ), n ) ] ) )

    return fdiv( result, fadd( n, 1 ) )
Exemple #39
0
def getAntiprismVolumeOperator(n, k):
    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')
Exemple #40
0
    def divide( self, other ):
        if isinstance( other, RPNMeasurement ):
            newValue = fdiv( self.value, other.value )

            factor, newUnits = combineUnits( self.getUnits( ), other.getUnits( ).inverted( ) )

            self = RPNMeasurement( fmul( newValue, factor ), newUnits )
        else:
            newValue = fdiv( self.value, other )

            self = RPNMeasurement( newValue, self.getUnits( ),
                                   self.getUnitName( ), self.getPluralUnitName( ) )

        return self.normalizeUnits( )
Exemple #41
0
def getPartitionNumber( n ):
    '''
    This version is, um, less recursive than the original, which I've kept.
    The strategy is to create a list of the smaller partition numbers we need
    to calculate and then start calling them recursively, starting with the
    smallest.  This will minimize the number of recursions necessary, and in
    combination with caching values, will calculate practically any integer
    partition without the risk of a stack overflow.

    I can't help but think this is still grossly inefficient compared to what's
    possible.  It seems that using this algorithm, calculating any integer
    partition ends up necessitating calculating the integer partitions of
    every integer smaller than the original argument.
    '''
    debugPrint( 'partition', int( n ) )

    if real_int( n ) < 0:
        raise ValueError( 'non-negative argument expected' )
    elif n in ( 0, 1 ):
        return 1

    sign = 1
    i = 1
    k = 1

    estimate = log10( fdiv( power( e, fmul( pi, sqrt( fdiv( fmul( 2, n ), 3 ) ) ) ),
                            fprod( [ 4, n, sqrt( 3 ) ] ) ) )
    if mp.dps < estimate + 5:
        mp.dps = estimate + 5

    partitionList = [ ]
    signList = [ ]

    while n - k >= 0:
        partitionList.append( ( fsub( n, k ), sign ) )
        i += 1

        if i % 2:
            sign *= -1

        k = getNthGeneralizedPolygonalNumber( i, 5 )

    partitionList = partitionList[ : : -1 ]

    total = 0

    for partition, sign in partitionList:
        total = fadd( total, fmul( sign, getPartitionNumber( partition ) ) )

    return total
def cheb_D(n: int) -> List[mp.mpf]:
    pts = cheb_pts(n)
    Dmat = [[0 for i in range(n)] for j in range(n)]

    N = n - 1

    Dmat[0][0] = mp.fdiv(mp.mpf(2) * mp.power(N, 2) + mp.mpf(1), mp.mpf(6))
    Dmat[N][N] = -mp.fdiv(mp.mpf(2) * mp.power(N, 2) + mp.mpf(1), mp.mpf(6))
    Dmat[0][N] = mp.mpf(0.5) * mp.power(-1, N)
    Dmat[N][0] = -mp.mpf(0.5) * mp.power(-1, N)

    for i in range(1, N):
        Dmat[0][i] = mp.mpf(2.0) * mp.power(-1, i) * mp.fdiv(
            1,
            mp.mpf(1) - pts[i])
        Dmat[N][i] = -mp.mpf(2.0) * mp.power(-1, i + N) * mp.fdiv(
            1,
            mp.mpf(1) + pts[i])
        Dmat[i][0] = -mp.mpf(0.5) * mp.power(-1, i) * mp.fdiv(
            1,
            mp.mpf(1) - pts[i])
        Dmat[i][N] = mp.mpf(0.5) * mp.power(-1, i + N) * mp.fdiv(
            1,
            mp.mpf(1) + pts[i])

        Dmat[i][i] = -0.5 * pts[i] * mp.fdiv(1,
                                             mp.mpf(1) - mp.power(pts[i], 2))

        for j in range(1, N):
            if i != j:
                Dmat[i][j] = mp.power(-1, i + j) * mp.fdiv(1, pts[i] - pts[j])

    return Dmat
Exemple #43
0
def solveQuadraticPolynomial( a, b, c ):
    if a == 0:
        if b == 0:
            raise ValueError( 'invalid expression, no variable coefficients' )
        else:
            # linear equation, one root
            return [ fdiv( fneg( c ), b ) ]
    else:
        d = sqrt( fsub( power( b, 2 ), fmul( 4, fmul( a, c ) ) ) )

        x1 = fdiv( fadd( fneg( b ), d ), fmul( 2, a ) )
        x2 = fdiv( fsub( fneg( b ), d ), fmul( 2, a ) )

        return [ x1, x2 ]
Exemple #44
0
def calculateHarmonicMean( args ):
    if isinstance( args, RPNGenerator ):
        return calculateHarmonicMean( list( args ) )
    elif isinstance( args, list ):
        if isinstance( args[ 0 ], ( list, RPNGenerator ) ):
            return [ calculateHarmonicMean( list( arg ) ) for arg in args ]
        else:
            sum = 0

            for arg in args:
                sum = fadd( sum, fdiv( 1, arg ) )

            return fdiv( len( args ), sum )
    else:
        return args
def get_fit_rate(mi, prob_success):
    if (prob_success == 1):
        return 0

    lna = mpmath.log(prob_success)
    lnasq = mpmath.fmul(lna, lna)

    term1 = mpmath.fdiv((mpmath.fsub(1, prob_success)), prob_success)
    term2 = mpmath.fdiv(term1, lnasq)

    mabf = term2
    mtbf = mpmath.fdiv(mpmath.fmul(mabf, mi.period), 3600000)

    fitrate = mpmath.fdiv(1000000000, mtbf)
    return fitrate
Exemple #46
0
def getPartitionNumber(n):
    '''
    This version is, um, less recursive than the original, which I've kept.
    The strategy is to create a list of the smaller partition numbers we need
    to calculate and then start calling them recursively, starting with the
    smallest.  This will minimize the number of recursions necessary, and in
    combination with caching values, will calculate practically any integer
    partition without the risk of a stack overflow.

    I can't help but think this is still grossly inefficient compared to what's
    possible.  It seems that using this algorithm, calculating any integer
    partition ends up necessitating calculating the integer partitions of
    every integer smaller than the original argument.
    '''
    debugPrint('partition', int(n))

    if n in (0, 1):
        return 1

    sign = 1
    i = 1
    k = 1

    estimate = log10(
        fdiv(power(e, fmul(pi, sqrt(fdiv(fmul(2, n), 3)))),
             fprod([4, n, sqrt(3)])))
    if mp.dps < estimate + 5:
        mp.dps = estimate + 5

    partitionList = []

    while n - k >= 0:
        partitionList.append((fsub(n, k), sign))
        i += 1

        if i % 2:
            sign *= -1

        k = getNthGeneralizedPolygonalNumber(i, 5)

    partitionList = partitionList[::-1]

    total = 0

    for partition, sign in partitionList:
        total = fadd(total, fmul(sign, getPartitionNumber(partition)))

    return total
Exemple #47
0
def getSuperRootsOperator(n, k):
    '''Returns all the super-roots of n, not just the nice, positive, real one.'''
    k = fsub(k, 1)
    factors = [fmul(i, root(k, k)) for i in unitroots(int(k))]
    base = root(fdiv(log(n), lambertw(fmul(k, log(n)))), k)

    return [fmul(i, base) for i in factors]
Exemple #48
0
def getSigma( target ):
    '''
    Returns the sum of the divisors of n, including 1 and n.

    http://math.stackexchange.com/questions/22721/is-there-a-formula-to-calculate-the-sum-of-all-proper-divisors-of-a-number
    '''
    n = floor( target )

    if real( n ) == 0:
        return 0
    elif n == 1:
        return 1

    factors = getECMFactors( n ) if g.ecm else getFactors( n )

    result = 1

    for factor in factors:
        numerator = fsub( power( factor[ 0 ], fadd( factor[ 1 ], 1 ) ), 1 )
        denominator = fsub( factor[ 0 ], 1 )
        #debugPrint( 'sigma', numerator, denominator )
        result = fmul( result, fdiv( numerator, denominator ) )

        if result != floor( result ):
            raise ValueError( 'insufficient precision for \'sigma\', increase precision (-p))' )

    return result
Exemple #49
0
    def distance_from_point(l0: Point, l1: Point, p: Point):
        '''
        source: http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
        condition: distance l0, l1 can't be zero
        :param l0:
        :param l1:
        :param p:
        :return:
        '''

        vec0 = Vector.create_from_points(l0, p)
        print("vec0", vec0)
        vec1 = Vector.create_from_points(l1, p)
        print("vec1", vec1)

        vec2 = Vector.create_from_points(l0, l1)
        print("vec2", vec2)
        vec_cx = vec0.cross(vec1)
        print("vec_cx", vec_cx)

        num_sq = vec_cx.dot(vec_cx)
        den_sq = vec2.dot(vec2)
        print("N:", num_sq)
        print("D:", den_sq)

        dist_sq = mpmath.fdiv(num_sq, den_sq)

        return mpmath.sqrt(dist_sq)
Exemple #50
0
def getCombinationsOperator(n, r):
    if r > n:
        raise ValueError(
            'number of elements {0} cannot exceed the size of the set {1}'.
            format(r, n))

    return fdiv(fac(n), fmul(fac(fsub(n, r)), fac(r)))
Exemple #51
0
def get_cycle_len(i):
    s = str(mp.fdiv(1, i, dps=100))
    print(s)
    for j in range(7, 12):
        if s[4:j + 4] == s[j + 4:j + j + 4]:
            return j
    return 0
Exemple #52
0
def compute_single_item_loss_list(u, node_capacity, n_seats, p0):
    u_to_the_n = math.power(u, node_capacity)
    C_fact = math.factorial(n_seats)
    C_to_the_n_minus_c = math.power(n_seats, (node_capacity - n_seats))
    denominator = math.fmul(C_fact, C_to_the_n_minus_c)
    fraction = math.fdiv(u_to_the_n, denominator)
    return math.fmul(fraction, p0)
Exemple #53
0
def pade_m(coef, e, m):
    # Calculation of analitical function on a arbitrary mesh for a given Pade coefficient
    # and first known momenta of function
    # e -  energy mesh (can be complex or real)
    # coef - Pade coefficients
    # m - first three momenta of function

    nlines = len(e)
    r = len(coef) / 2
    f = mp.zeros(nlines, 1)
    pq = mp.ones(r * 2 + 1, 1)
    # for i in range(0, r):
    # pq[i] = coef[i]
    # pq[i + r] = coef[i + r]
    for iw in range(0, nlines):
        p = mp.mpc(0.0)
        q = mp.mpc(0.0)
        for i in range(0, r):
            p += coef[i] * e[iw]**i
        for i in range(0, r + 1):
            q += coef[i + r] * e[iw]**i

        f[iw] = fdiv(p, q)

        # f[iw] = np.divide(p, q)
        f[iw] /= e[iw]**3
        f[iw] += m[0] / e[iw] + m[1] / (e[iw]**2) + m[2] / (e[iw]**3)
    f = fp.matrix(f)
    return f
Exemple #54
0
def divide( n, k ):
    if isinstance( n, RPNMeasurement ):
        return n.divide( k )
    elif isinstance( k, RPNMeasurement ):
        return RPNMeasurement( n ).divide( k )
    else:
        return fdiv( n, k )
Exemple #55
0
def compute_formula_second_term(u_divided_by_nseat, node_capacity, n_seats, u):
    u_to_c_over_c_fact = math.fdiv(math.power(u, n_seats),
                                   math.factorial(n_seats))
    second_fraction = 0

    if u_divided_by_nseat == 1:
        second_fraction = node_capacity - n_seats + 1
    else:
        u_div_C_to_K_minus_C_plus1 = math.power(u_divided_by_nseat,
                                                (node_capacity - n_seats + 1))
        one_minus_u_div_C = math.fsub(1, u_divided_by_nseat)
        second_fraction_numerator = math.fsub(1, u_div_C_to_K_minus_C_plus1)
        second_fraction = math.fdiv(second_fraction_numerator,
                                    one_minus_u_div_C)

    return math.fmul(u_to_c_over_c_fact, second_fraction)
Exemple #56
0
    def combineUnits(self, units):
        if not g.unitConversionMatrix:
            loadUnitConversionMatrix()

        newUnits = RPNUnits(self)

        factor = mpmathify(1)

        for unit2 in units:
            if unit2 in newUnits:
                newUnits[unit2] += units[unit2]
            else:
                for unit1 in self:
                    if unit1 == unit2:
                        newUnits[unit2] += units[unit2]
                        break

                    if getUnitType(unit1) == getUnitType(unit2):
                        factor = fdiv(
                            factor,
                            pow(
                                mpmathify(g.unitConversionMatrix[(unit1,
                                                                  unit2)]),
                                units[unit2]))
                        newUnits[unit1] += units[unit2]
                        break
                else:
                    newUnits[unit2] = units[unit2]

        #print( 'newUnits', newUnits )
        return factor, newUnits
Exemple #57
0
def calculateHarmonicMean( args ):
    if isinstance( args, RPNGenerator ):
        return calculateHarmonicMean( list( args ) )

    if isinstance( args, list ):
        if isinstance( args[ 0 ], ( list, RPNGenerator ) ):
            return [ calculateHarmonicMean( list( arg ) ) for arg in args ]

        result = 0

        for arg in args:
            result = fadd( result, fdiv( 1, arg ) )

        return fdiv( len( args ), result )

    return args
Exemple #58
0
def pade(coef, e):
    # Calculation of analitical function on a arbitrary mesh for a given Pade coefficient
    # e -  energy mesh (can be complex or real)
    # coef - Pade coefficients

    nlines = len(e)
    r = len(coef) // 2
    f = mp.zeros(nlines, 1)
    # pq = mp.ones(r * 2 + 1, 1)
    # for i in range(0, r):
    # pq[i] = coef[i]
    # pq[i + r] = coef[i + r]
    for iw in range(0, nlines):
        p = mp.mpc(0.0)
        q = mp.mpc(0.0)
        for i in range(0, r):
            p += coef[i] * e[iw]**i
        for i in range(0, r):
            #             print(i, r, i+r)
            q += coef[i + r] * e[iw]**i

        # f[iw] = np.divide(p, q)
        f[iw] = fdiv(p, q)
    f = fp.matrix(f)
    return f
Exemple #59
0
def getNthOctagonalHeptagonalNumberOperator(n):
    return nint(
        floor(
            fdiv(
                fmul(fadd(17, fmul(sqrt(30), 2)),
                     power(fadd(sqrt(5), sqrt(6)), fsub(fmul(8, n), 6))),
                480)))