Beispiel #1
1
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
Beispiel #2
0
def expectResult( command, expected ):
    if g.testFilter:
        if g.testFilter not in command:
            return

    if g.timeIndividualTests:
        startTime = time.process_time( )

    print( 'rpn', command )
    result = rpn( shlex.split( command + ' -I' ) )[ 0 ]

    compare = None

    if isinstance( expected, list ):
        compare = [ ]

        for i in expected:
            if isinstance( i, ( int, float, complex ) ):
                compare.append( mpmathify( i ) )
            else:
                compare.append( i )
    else:
        if isinstance( expected, ( int, float, complex ) ):
            compare = mpmathify( expected )
        else:
            compare = expected

    compareResults( result, compare )

    print( '    test passed!' )

    if g.timeIndividualTests:
        print( 'Test complete.  Time elapsed:  {:.3f} seconds'.format( time.process_time( ) - startTime ) )

    print( '' )
Beispiel #3
0
def f(x, y, z):
    x = mp.mpmathify(x)
    y = mp.mpmathify(y)
    z = mp.mpmathify(z)

    R = radius(x, y, z)

    # solving 0 division problem here

    if x == 0 and z == 0 or y == 0:
        part1 = mp.mpmathify(0)
    else:
        part1 = mp.mpf('0.5') * y * (mp.power(z, 2) - mp.power(
            x, 2)) * mp.asinh(y / (mp.sqrt(mp.power(x, 2) + mp.power(z, 2))))

    if x == 0 and y == 0 or z == 0:
        part2 = 0
    else:
        part2 = mp.mpf('0.5') * z * (mp.power(y, 2) - mp.power(
            x, 2)) * mp.asinh(z / (mp.sqrt(mp.power(x, 2) + mp.power(y, 2))))

    if x == 0 or y == 0 or z == 0:
        part3 = 0
    else:
        part3 = x * y * z * mp.atan((y * z) / (x * R))

    # solving 0 division problem here

    part4 = mp.mpf('1 / 6') * R * (2 * mp.power(x, 2) - mp.power(y, 2) -
                                   mp.power(z, 2))

    return mp.mpmathify(part1 + part2 - part3 + part4)
Beispiel #4
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
Beispiel #5
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
Beispiel #6
0
    def simulate_single(self, energy, rate):
        if energy <= self.axion_mass:
            return
        br = mpmathify(self.branching_ratio(energy, self.axion_coupling))
        axion_p = mp.sqrt(energy**2 - self.axion_mass**2)
        axion_v = mpmathify(axion_p / energy)

        axion_boost = mpmathify(energy / self.axion_mass)
        tau = mpmathify(64 * pi /
                        (self.axion_coupling**2 * self.axion_mass**3) *
                        axion_boost)
        surv_prob = mp.exp(-self.detector_distance / meter_by_mev / axion_v /
                           tau)
        decay_in_detector = fsub(
            1, mp.exp(-self.detector_length / meter_by_mev / axion_v / tau))

        self.axion_velocity.append(axion_v)
        self.axion_energy.append(energy)
        self.axion_flux.append(rate * br /
                               (4 * pi * self.detector_distance**2))
        self.decay_axion_weight.append(rate * br * surv_prob *
                                       decay_in_detector /
                                       (4 * pi * self.detector_distance**2))
        self.scatter_axion_weight.append(surv_prob * rate * br /
                                         (4 * pi * self.detector_distance**2))
Beispiel #7
0
def convertToBase10( integer, mantissa, inputRadix ):
    result = mpmathify( 0 )
    base = mpmathify( 1 )

    validNumerals = g.numerals[ : inputRadix ]

    for i in range( len( integer ) - 1, -1, -1 ):
        digit = validNumerals.find( integer[ i ] )

        if digit == -1:
            raise ValueError( 'invalid numeral \'%c\' for base %d' % ( integer[ i ], inputRadix ) )

        result += digit * base
        base *= inputRadix

    base = fdiv( 1, inputRadix )

    for i in range( 0, len( mantissa ) ):
        digit = validNumerals.find( mantissa[ i ] )

        if digit == -1:
            raise ValueError( 'invalid numeral \'%c\' for base %d' % ( mantissa[ i ], inputRadix ) )

        result += digit * base
        base /= inputRadix

    return result
def stringExpressionValid(str):
    try:
        mpmath.mpmathify(str)
        return True
    except Exception as err:
        print(err)
        return False
Beispiel #9
0
def times_a(array1, array2):
    from  mpmath import mp as math
    math.prec = 200
    a1 = list(array1)
    a2 = list(array2)
    output = [math.fmul(math.mpmathify(a1[i]),math.mpmathify(a2[i])) for i in range(len(a1))]
    return output
Beispiel #10
0
    def create_hexagonal_grid_nearestN(origin, d, point, N):
        """
        Create a new coherent basis with basis states on a hexagonal grid.

        As basis states the nearest N grid points to the center are choosen.

        *Arguments*
            * *origin*
                A complex number defining the origin of the grid.

            * *d*
                A real number defining the lattice constant.

            * *point*
                A complex number used as reference point to which the nearest
                N lattice points are selected.

            * *N*
                An integer giving the number of basis states.
        """
        origin = mpmath.mpmathify(origin)
        point = mpmath.mpmathify(point)
        d = mpmath.mpf(d)
        lat = lattice.HexagonalLattice(d, origin, dtype=mpmath.mpf)
        lat.select_nearestN(point, N)
        return CoherentBasis(lat)
Beispiel #11
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
                    elif 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
Beispiel #12
0
def convertToBase10(integer, mantissa, inputRadix):
    result = mpmathify(0)
    base = mpmathify(1)

    validNumerals = g.numerals[:inputRadix]

    for i in range(len(integer) - 1, -1, -1):
        digit = validNumerals.find(integer[i])

        if digit == -1:
            raise ValueError('invalid numeral \'%c\' for base %d' %
                             (integer[i], inputRadix))

        result += digit * base
        base *= inputRadix

    base = fdiv(1, inputRadix)

    for i, numeral in enumerate(mantissa):
        digit = validNumerals.find(numeral)

        if digit == -1:
            raise ValueError('invalid numeral \'%c\' for base %d' %
                             (mantissa[i], inputRadix))

        result += digit * base
        base /= inputRadix

    return result
Beispiel #13
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 ) ]
Beispiel #14
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 ) ]
Beispiel #15
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 ) ]
Beispiel #16
0
def wme_gen(f, pYs_p, pZs_p, X, alpha, g_p, delta=0):
    # convert probabilities to mpmath.mpf
    pYs = [{k: mpmath.mpmathify(pY[k]) for k in pY} for pY in pYs_p]
    pZs = [{k: mpmath.mpmathify(pZ[k]) for k in pZ} for pZ in pZs_p]
    g = {w: {y: mpmath.mpmathify(g_p[w][y]) for y in g_p[w]} for w in g_p}
    delta = mpmath.mpmathify(delta)

    # precondition
    # bypass precondition if number of arguments == 0, i.e. if f is defined as a function of another function
    if len(X) + len(pYs) + len(pZs) != len(inspect.getargspec(f)[0]) and len(
            inspect.getargspec(f)[0]) != 0:
        sys.exit(
            "Aborted: Number of function arguments and inputs didn't match")

    if len(inspect.getargspec(f)[0]) == 0:
        try:
            a = f(*((0, ) * (len(X) + len(pYs) + len(pZs))))
        except KeyError:
            # here we tolerate KeyError because merged functions might not recognise input (0, 0, ...)
            pass
        except:
            sys.exit(
                "Aborted: Number of function arguments and inputs didn't match"
            )

    # joint distribution for Output and Y
    pOaY = dict()
    for Y in itertools.product(*pYs):
        for Z in itertools.product(*pZs):
            o = f(*(X + Y + Z))
            p_o = prod((pYZ[yz] for (yz, pYZ) in zip(Y + Z, pYs + pZs)))
            # critical for distributions with a zero probability!
            # next line ensures that only possible events appear in pO (the if)
            if p_o > 0:
                if o in pOaY:
                    if Y in pOaY[o]:
                        pOaY[o][Y] += p_o
                    else:
                        pOaY[o][Y] = p_o
                else:
                    pOaY[o] = {Y: p_o}

    # W[o] is the vector inside the norm (over guesses w)
    W = dict()
    for o in pOaY:
        W[o] = [
            sum(pOaY[o][Y] * g[w][Y] for Y in g[w] if Y in pOaY[o]) + delta
            for w in g
        ]

    if alpha == -1:
        sum_o = sum(max(W[o]) for o in pOaY)
        result = -mpmath.log(sum_o, b=2)
    else:
        sum_o = sum(p_norm(W[o], alpha) for o in pOaY)
        result = (alpha / (1 - alpha)) * mpmath.log(sum_o, b=2)

    return result
Beispiel #17
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)
    ]
Beispiel #18
0
    def getAzimuthAndAltitude( 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 )

        return RPNMeasurement( mpmathify( self.object.az ), 'radians' ), \
               RPNMeasurement( mpmathify( self.object.alt ), 'radians' )
Beispiel #19
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
Beispiel #20
0
    def getAzimuthAndAltitude( 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 )

        return RPNMeasurement( mpmathify( self.object.az ), 'radians' ), \
               RPNMeasurement( mpmathify( self.object.alt ), 'radians' )

        return self.getAzimuthAndAltitude( )
def doubledouble2string(doubdoub,n=19):
    """
    Convert a double-double tuple into a string with n decimal digits of precision.  Default is n=19,
    which is the maximum precision that this longdouble-based double-double format can provide.
    min_fixed is the position of the leading digit such that any number with a leading
    digit less than or equal to min_fixed will be written in exponential format.
    e.g., 0.00123 has its leading digit in the -3 place, so if min_fixed>=-3
    it will be printed as 1.23e-3, and if min_fixed<=-4 it will be printed as 0.00123.
    """
    mpmath.mp.prec=105
    hi=mpmath.mpmathify(doubdoub[0])
    lo=mpmath.mpmathify(doubdoub[1])
    tot=mpmath.fadd(hi,lo)
    return mpmath.nstr(tot,n)
Beispiel #22
0
def doubledouble2string(doubdoub, n=19):
    """
    Convert a double-double tuple into a string with n decimal digits of precision.  Default is n=19,
    which is the maximum precision that this longdouble-based double-double format can provide.
    min_fixed is the position of the leading digit such that any number with a leading
    digit less than or equal to min_fixed will be written in exponential format.
    e.g., 0.00123 has its leading digit in the -3 place, so if min_fixed>=-3
    it will be printed as 1.23e-3, and if min_fixed<=-4 it will be printed as 0.00123.
    """
    mpmath.mp.prec = 105
    hi = mpmath.mpmathify(doubdoub[0])
    lo = mpmath.mpmathify(doubdoub[1])
    tot = mpmath.fadd(hi, lo)
    return mpmath.nstr(tot, n)
Beispiel #23
0
    def polish(self, init_shapes, flag_initial_error=True):
        """Use Newton's method to compute precise shapes from rough ones."""
        precision = self._precision
        manifold = self.manifold
        #working_prec = precision + 32
        working_prec = precision + 64
        mpmath.mp.prec = working_prec
        target_epsilon = mpmath.mpmathify(2.0)**-precision
        det_epsilon = mpmath.mpmathify(2.0)**(32 - precision)
        #shapes = [mpmath.mpmathify(z) for z in init_shapes]
        shapes = mpmath.matrix(init_shapes)
        init_equations = manifold.gluing_equations('rect')
        target = mpmath.mpmathify(self.target_holonomy)
        error = self._gluing_equation_error(init_equations, shapes, target)
        if flag_initial_error and error > 0.000001:
            raise GoodShapesNotFound(
                'Initial solution not very good: error=%s' % error)

        # Now begin the actual computation

        eqns = enough_gluing_equations(manifold)
        assert eqns[-1] == manifold.gluing_equations('rect')[-1]
        for i in range(100):
            errors = self._gluing_equation_errors(eqns, shapes, target)
            if infinity_norm(errors) < target_epsilon:
                break
            derivative = [[
                int(eqn[0][i]) / z - int(eqn[1][i]) / (1 - z)
                for i, z in enumerate(shapes)
            ] for eqn in eqns]
            derivative[-1] = [target * x for x in derivative[-1]]
            derivative = mpmath.matrix(derivative)
            #det = derivative.matdet().abs()
            det = abs(mpmath.det(derivative))
            if min(det, 1 / det) < det_epsilon:
                raise GoodShapesNotFound(
                    'Gluing system is too singular (|det| = %s).' % det)
            delta = mpmath.lu_solve(derivative, errors)
            shapes = shapes - delta

        # Check to make sure things worked out ok.
        error = self._gluing_equation_error(init_equations, shapes, target)
        #total_change = infinity_norm(init_shapes - shapes)
        if error > 1000 * target_epsilon:
            raise GoodShapesNotFound('Failed to find solution')
        #if flag_initial_error and total_change > pari(0.0000001):
        #    raise GoodShapesNotFound('Moved too far finding a good solution')
        self.shapelist = [Number(z, precision=precision) for z in shapes]
Beispiel #24
0
def convertToBaseN( value, base, outputBaseDigits, numerals ):
    if outputBaseDigits:
        if ( base < 2 ):
            raise ValueError( 'base must be greater than 1' )
    else:
        if not ( 2 <= base <= len( numerals ) ):
            raise ValueError( 'base must be from 2 to {0}'.format( len( numerals ) ) )

    if value == 0:
        return 0

    if value < 0:
        return '-' + convertToBaseN( fneg( value ), base, outputBaseDigits, numerals )

    if base == 10:
        return str( value )

    if outputBaseDigits:
        result = [ ]
    else:
        result = ''

    leftDigits = mpmathify( value )

    while leftDigits > 0:
        modulo = fmod( leftDigits, base )

        if outputBaseDigits:
            result.insert( 0, int( modulo ) )
        else:
            result = numerals[ int( modulo ) ] + result

        leftDigits = floor( fdiv( leftDigits, base ) )

    return result
Beispiel #25
0
def downloadOEISSequence( id ):
    '''Downloads and formats data from oeis.org.'''
    keywords = downloadOEISText( id, 'K' ).split( ',' )

    # If oeis.org isn't available, just punt everything
    if keywords == [ '' ]:
        return 0

    result, success = downloadOEISTable( id )

    if success:
        return result

    if 'nonn' in keywords:
        result = downloadOEISText( id, 'S' )
        result += downloadOEISText( id, 'T' )
        result += downloadOEISText( id, 'U' )
    else:
        result = downloadOEISText( id, 'V' )
        result += downloadOEISText( id, 'W' )
        result += downloadOEISText( id, 'X' )

    if 'cons' in keywords:
        offset = int( downloadOEISText( id, 'O' ).split( ',' )[ 0 ] )
        result = ''.join( result.split( ',' ) )
        return mpmathify( result[ : offset ] + '.' + result[ offset : ] )
    else:
        #return [ mpmathify( i ) for i in result.split( ',' ) ]
        return [ int( i ) for i in result.split( ',' ) ]
Beispiel #26
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
Beispiel #27
0
def downloadOEISSequence(aNumber):
    '''Downloads and formats data from oeis.org.'''
    keywords = downloadOEISText(aNumber, 'K').split(',')

    # If oeis.org isn't available, just punt everything
    if keywords == ['']:
        return 0

    result, success = downloadOEISTable(aNumber)

    if success:
        return result

    if 'nonn' in keywords:
        result = downloadOEISText(aNumber, 'S')
        result += downloadOEISText(aNumber, 'T')
        result += downloadOEISText(aNumber, 'U')
    else:
        result = downloadOEISText(aNumber, 'V')
        result += downloadOEISText(aNumber, 'W')
        result += downloadOEISText(aNumber, 'X')

    if 'cons' in keywords:
        offset = int(downloadOEISText(aNumber, 'O').split(',')[0])
        result = ''.join(result.split(','))
        return mpmathify(result[:offset] + '.' + result[offset:])

    # return [ mpmathify( i ) for i in result.split( ',' ) ]
    return [int(i) for i in result.split(',')]
Beispiel #28
0
def nu_linregress(x, y):
    """
    Refactor of the scipy linregress with numba and less checks for speed sake

    :param x: array for independent
    :param y:
    :return:
    """
    cols = ['slope', 'intercept', 'rvalue', 'pvalue', 'stderr']
    #LinregressResult = namedtuple('LinregressResult', cols)
    #TINY = 1.0e-20
    x = np.asarray(x)
    y = np.asarray(y)
    arr = np.array([x, y])
    n = len(x)
    xmean = np.mean(x, None)
    ymean = np.mean(y, None)
    # average sum of squares:
    ssxm, ssxym, ssyxm, ssym = (np.dot(arr, arr.T) / n).flat
    r_num = mp.mpmathify(ssxym)
    r_den = mp.sqrt(ssxm * ssym)
    r = r_num / r_den
    # test for numerical error propagation
    if r > 1.0:
        r = 1.0
    elif r < -1.0:
        r = -1.0
    df = n - 2
    slope = r_num / ssxm
    intercept = ymean - slope * xmean
    t = r * np.sqrt(df / ((1.0 - r) * (1.0 + r)))
    prob = t_sf(np.abs(t), df)
    sterrest = np.sqrt((1 - r**2) * ssym / ssxm / df)
    return dict(zip(cols, [slope, intercept, r, prob, sterrest]))
Beispiel #29
0
    def create_hexagonal_grid_rings(center, d, rings):
        """
        Create a new coherent basis with basis states on a hexagonal grid.

        The basis states are choosen in rings around the center on a hexagonal
        grid with lattice constant d.

        *Arguments*
            * *center*
                A complex number defining the center of the rings.

            * *d*
                A real number defining the lattice constant.

            * *rings*
                An integer giving the number of rings.
        """
        center = mpmath.mpmathify(center)
        d = mpmath.mpf(d)
        lat = lattice.HexagonalLattice(d, center, dtype=mpmath.mpf)
        for i in range(-rings,rings+1):
            if i<0:
                start = -rings-i
                end = rings
            else:
                start = -rings
                end = rings-i
            for j in range(start,end+1):
                lat.select((i, j))
        return CoherentBasis(lat)
Beispiel #30
0
def lifeDist(vMin=-35, vMax=15, tMin=14, tMax=17, mean=0, sigma=14):
    V = (mpmathify(10**(vMin)), mpmathify(10**(vMax)))
    t = (mpmathify(10**(tMin)), mpmathify(10**(tMax)))

    mp.dps = 230

    val = mpf('1')
    r = np.random.lognormal(mean, sigma)
    #r = np.random.normal(mean,sigma)
    val *= r
    val *= sampleU(V)
    val *= sampleU(t)
    val = 0 - val
    expo = mp.exp(val)
    val = mpf('1') - expo
    mp.dps = 15
    return val
Beispiel #31
0
def getRightTruncations( n ):
    if n < 0:
        raise ValueError( '\'get_right_truncations\' requires a positive argument' )

    str = getMPFIntegerAsString( n )

    for i in range( len( str ), 0, -1 ):
        yield mpmathify( str[ 0 : i ] )
Beispiel #32
0
def getLeftTruncations( n ):
    if n < 0:
        raise ValueError( '\'get_left_truncations\' requires a positive argument' )

    str = getMPFIntegerAsString( n )

    for i, e in enumerate( str ):
        yield mpmathify( str[ i : ] )
Beispiel #33
0
def runYAFU(n):
    fullOut = subprocess.run([
        g.userConfiguration['yafu_path'] + os.sep +
        g.userConfiguration['yafu_binary'], '-xover', '120'
    ],
                             input='factor(' + str(int(n)) + ')\n',
                             encoding='ascii',
                             stdout=subprocess.PIPE,
                             cwd=g.userConfiguration['yafu_path'],
                             check=True).stdout

    #print( 'out', fullOut )

    out = fullOut[fullOut.find('***factors found***'):]

    if len(out) < 2:
        if log10(n) > 40:
            raise ValueError('yafu seems to have crashed trying to factor ' +
                             str(int(n)) + '.\n\nyafu output follows:\n' +
                             fullOut)

        debugPrint(
            'yafu seems to have crashed, switching to built-in factoring code')
        return factorise(int(n))

    result = []

    while True:
        prime = ''

        out = out[out.find('P'):]

        if len(out) < 2:
            break

        out = out[out.find('='):]

        index = 2

        while out[index] >= '0' and out[index] <= '9':
            prime += out[index]
            index += 1

        result.append(mpmathify(prime))

    if not result:
        raise ValueError('yafu seems to have failed.')

    answer = fprod(result)

    if answer != n:
        debugPrint('\nyafu has barfed')
        for i in result:
            n = fdiv(n, i)

        result.extend(runYAFU(n))

    return sorted(result)
Beispiel #34
0
def sph_kn_exact(n, z):
    """Return the value of k_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E12 .

    """
    zm = mpmathify(z)
    s = sum(_a(k, n)/zm**(k+1) for k in xrange(n+1))
    return pi*exp(-zm)/2*s
Beispiel #35
0
def getThueMorseConstant( ):
    result = 0
    factor = mpmathify( '0.5' )

    for i in arange( 0, mp.prec + 1 ):
        result = fadd( result, fmul( getNthThueMorseNumber( i ), factor ) )
        factor = fdiv( factor, 2 )

    return result
Beispiel #36
0
def sph_kn_exact(n, z):
    """Return the value of k_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E12 .

    """
    zm = mpmathify(z)
    s = sum(_a(k, n) / zm**(k + 1) for k in xrange(n + 1))
    return pi * exp(-zm) / 2 * s
Beispiel #37
0
def sph_h2n_exact(n, z):
    """Return the value of h^{(2)}_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E7 .

    """
    zm = mpmathify(z)
    s = sum(mpc(0,-1)**(k-n-1)*_a(k, n)/zm**(k+1) for k in xrange(n+1))
    return exp(mpc(0,-1)*zm)*s
Beispiel #38
0
def getThueMorseConstant( ):
    result = 0
    factor = mpmathify( '0.5' )

    for i in arange( 0, mp.prec + 1 ):
        result = fadd( result, fmul( getNthThueMorse( i ), factor ) )
        factor = fdiv( factor, 2 )

    return result
Beispiel #39
0
 def __init__(self, value, units=RPNUnits()):
     if isinstance(value, (str, int)):
         self.value = mpmathify(value)
         self.units = RPNUnits(units)
     elif isinstance(value, RPNMeasurement):
         self.value = value.value
         self.units = RPNUnits(value.units)
     else:
         self.value = value
         self.units = RPNUnits(units)
Beispiel #40
0
def sph_i2n_exact(n, z):
    """Return the value of i^{(2)}_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E10 .

    """
    zm = mpmathify(z)
    s1 = sum(mpc(-1,0)**k * _a(k, n)/zm**(k+1) for k in xrange(n+1))
    s2 = sum(_a(k, n)/zm**(k+1) for k in xrange(n+1))
    return exp(zm)/2 * s1 + mpc(-1,0)**n*exp(-zm)/2 * s2
Beispiel #41
0
def sph_yn_exact(n, z):
    """Return the value of y_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E4 .

    """
    zm = mpmathify(z)
    s1 = sum((-1)**k*_a(2*k, n)/zm**(2*k+1) for k in xrange(0, int(n/2) + 1))
    s2 = sum((-1)**k*_a(2*k+1, n)/zm**(2*k+2) for k in xrange(0, int((n-1)/2) + 1))
    return -cos(zm - n*pi/2)*s1 + sin(zm - n*pi/2)*s2
Beispiel #42
0
def getCyclicPermutationsOperator(n):
    result = [n]

    n = getMPFIntegerAsString(n)

    for _ in range(len(n) - 1):
        n = n[1:] + n[:1]
        result.append(mpmathify(n))

    return result
Beispiel #43
0
def sph_i2n_exact(n, z):
    """Return the value of i^{(2)}_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E10 .

    """
    zm = mpmathify(z)
    s1 = sum(mpc(-1, 0)**k * _a(k, n) / zm**(k + 1) for k in xrange(n + 1))
    s2 = sum(_a(k, n) / zm**(k + 1) for k in xrange(n + 1))
    return exp(zm) / 2 * s1 + mpc(-1, 0)**n * exp(-zm) / 2 * s2
Beispiel #44
0
 def __init__( self, value, units = RPNUnits( ) ):
     if isinstance( value, str ):
         self.value = mpmathify( value )
         self.units = RPNUnits( units )
     elif isinstance( value, RPNMeasurement ):
         self.value = value.value
         self.units = RPNUnits( value.units )
     else:
         self.value = value
         self.units = RPNUnits( units )
Beispiel #45
0
def replaceDigitsOperator(n, source, replace):
    n = getMPFIntegerAsString(n)

    if source < 0:
        raise ValueError('source value must be a positive integer')

    if replace < 0:
        raise ValueError('replace value must be a positive integer')

    return mpmathify(n.replace(str(int(source)), str(int(replace))))
Beispiel #46
0
def sph_h1n_exact(n, z):
    """Return the value of h^{(1)}_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E6 .

    """
    zm = mpmathify(z)
    s = sum(
        mpc(0, 1)**(k - n - 1) * _a(k, n) / zm**(k + 1) for k in xrange(n + 1))
    return exp(mpc(0, 1) * zm) * s
Beispiel #47
0
def formatOutput( output ):
    # filter out text strings
    for c in output:
        if c in '+-.':
            continue

        # anything with embedded whitespace is a string
        if c in string.whitespace or c in string.punctuation:
            return output

    #print( )
    #print( 'formatOutput 1:', output )

    # override settings with temporary settings if needed
    # if g.tempCommaMode:
    #     comma = True
    # else:
    #     comma = g.comma

    # output settings, which may be overrided by temp settings
    outputRadix = g.outputRadix
    integerGrouping = g.integerGrouping
    leadingZero = g.leadingZero

    if g.tempHexMode:
        integerGrouping = 4
        leadingZero = True
        outputRadix = 16

    if g.tempLeadingZeroMode:
        leadingZero = True

    if g.tempOctalMode:
        integerGrouping = 3
        leadingZero = True
        outputRadix = 8

    mpOutput = mpmathify( output )

    imaginary = im( mpOutput )
    real = re( mpOutput )

    result, negative = formatNumber( real, outputRadix, leadingZero, integerGrouping )

    if negative:
        result = '-' + result

    if imaginary != 0:
        strImaginary, negativeImaginary = formatNumber( imaginary, outputRadix, leadingZero )
        result = '( ' + result + ( ' - ' if negativeImaginary else ' + ' ) + strImaginary + 'j )'

    #print( 'formatOutput 2:', output )
    #print( )

    return result
Beispiel #48
0
def formatOutput( output ):
    # filter out text strings
    for c in output:
        if c in '+-.':
            continue

        # anything with embedded whitespace is a string
        if c in string.whitespace or c in string.punctuation:
            return output

    # output settings, which may be overrided by temp settings
    outputRadix = g.outputRadix
    integerGrouping = g.integerGrouping
    leadingZero = g.leadingZero
    integerDelimiter = g.integerDelimiter

    # override settings with temporary settings if needed
    if g.tempCommaMode:
        integerGrouping = 3     # override whatever was set on the command-line
        leadingZero = False     # this one, too
        integerDelimiter = ','

    if g.tempHexMode:
        integerGrouping = 4
        leadingZero = True
        outputRadix = 16

    if g.tempLeadingZeroMode:
        leadingZero = True

    if g.tempOctalMode:
        integerGrouping = 3
        leadingZero = True
        outputRadix = 8

    mpOutput = mpmathify( output )

    imaginary = im( mpOutput )
    real = re( mpOutput )

    result, negative = formatNumber( real, outputRadix, leadingZero, integerGrouping,
                                     integerDelimiter, g.decimalDelimiter )

    if negative:
        result = '-' + result

    if imaginary != 0:
        strImaginary, negativeImaginary = \
            formatNumber( imaginary, outputRadix, leadingZero, integerGrouping, integerDelimiter, g.DecimalDelimiter )
        result = '( ' + result + ( ' - ' if negativeImaginary else ' + ' ) + strImaginary + 'j )'

    #print( 'formatOutput 2:', output )
    #print( )

    return result
Beispiel #49
0
def g(x, y, z):
    x = mp.mpmathify(x)
    y = mp.mpmathify(y)
    z = mp.mpmathify(z)

    R = radius(x, y, z)

    if x == 0 and y == 0:
        part1 = mp.mpf('0')
    else:
        part1 = x * y * z * mp.asinh(
            z / (mp.sqrt(mp.power(x, 2) + mp.power(y, 2))))

    if y == 0 and z == 0:
        part2 = mp.mpf('0')
    else:
        part2 = mp.mpf('1 / 6') * y * (3 * mp.power(z, 2) - mp.power(
            y, 2)) * mp.asinh(x / (mp.sqrt(mp.power(y, 2) + mp.power(z, 2))))

    if x == 0 and z == 0:
        part3 = 0
    else:
        part3 = mp.mpf('1 / 6') * x * (3 * mp.power(z, 2) - mp.power(
            x, 2)) * mp.asinh(y / (mp.sqrt(mp.power(x, 2) + mp.power(z, 2))))

    if y == 0:
        part4 = 0
    else:
        part4 = mp.mpf('0.5') * mp.power(y, 2) * z * mp.atan((x * z) / (y * R))

    if x == 0:
        part5 = 0
    else:
        part5 = mp.mpf('0.5') * mp.power(x, 2) * z * mp.atan((y * z) / (x * R))

    if z == 0:
        part6 = 0
    else:
        part6 = mp.mpf('1 / 6') * mp.power(z, 3) * mp.atan((x * y) / (z * R))

    part7 = mp.mpf('1 / 3') * x * y * R
    return mp.mpmathify(part1 + part2 + part3 - part4 - part5 - part6 - part7)
Beispiel #50
0
def interpretAsBase( args, base ):
    if isinstance( args, list ):
        args.reverse( )
    else:
        args = [ args ]

    if isinstance( base, list ):
        return [ interpretAsBase( args, i ) for i in base ]

    value = mpmathify( 0 )
    multiplier = mpmathify( 1 )

    for i in args:
        if i >= real_int( base ):
            raise ValueError( 'invalid value for base', int( base ) )

        value = fadd( value, fmul( i, multiplier ) )
        multiplier = fmul( multiplier, base )

    return value
Beispiel #51
0
def click(event):
    global waiting
    #convert click location to pix address
    x = (event.x - centerx * z) / z + 1
    y = (event.y - centery * z) / z + 1
    qev = mpmath.mpmathify(complex(x, y))
    if event.type == 4 or not eventqueue or eventqueue[-1] != qev:
        eventqueue.append(qev)
    if waiting:
        waiting = False
        master.after_idle(main)
Beispiel #52
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' )
Beispiel #53
0
    def getAngularSeparation( self, other, location, date ):
        if isinstance( location, str ):
            location = getLocation( location )

        location.observer.date = date.to( 'utc' ).format( )

        self.object.compute( location.observer )
        other.object.compute( location.observer )

        return RPNMeasurement( mpmathify( ephem.separation( ( self.object.az, self.object.alt ),
                                                            ( other.object.az, other.object.alt ) ) ), 'radian' )
Beispiel #54
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' )
Beispiel #55
0
    def getAngularSeparation( self, other, location, date ):
        if isinstance( location, str ):
            location = getLocation( location )

        location.observer.date = date.to( 'utc' ).format( )

        self.object.compute( location.observer )
        other.object.compute( location.observer )

        return RPNMeasurement( mpmathify( ephem.separation( ( self.object.az, self.object.alt ),
                                                            ( other.object.az, other.object.alt ) ) ), 'radian' )
Beispiel #56
0
def logHistogramAdd(start, end, size, dist, value):
    start = mpf(start)
    end = mpf(end)
    step = mpf((end - start) / size)
    for i in range(1, size):
        current = mpmathify(10**(start + step * i))
        if value < current:
            dist[i - 1] += 1
            return dist
    dist[-1] += 1
    return dist
Beispiel #57
0
def getConstant( name ):
    if name not in g.constantOperators:
        raise ValueError( 'Invalid constant: ', name )

    unit = g.constantOperators[ name ].unit
    value = g.constantOperators[ name ].value

    if unit == '':
        return mpmathify( value )
    else:
        return RPNMeasurement( value, unit )
Beispiel #58
0
def getConstant( name ):
    if name not in g.constantOperators:
        raise ValueError( 'Invalid constant: ', name )

    unit = g.constantOperators[ name ].unit
    value = g.constantOperators[ name ].value

    if unit == '':
        return mpmathify( value )

    return RPNMeasurement( value, unit )
Beispiel #59
0
def runYAFU( n ):
    import subprocess

    full_out = subprocess.run( [ g.userConfiguration[ 'yafu_path' ] + os.sep +
                                 g.userConfiguration[ 'yafu_binary' ], str( int( n ) ), '-xover', '120' ],
                             stdout=subprocess.PIPE, cwd=g.userConfiguration[ 'yafu_path' ] ).stdout.decode( 'ascii' )

    #print( 'out', full_out )

    out = full_out[ full_out.find( '***factors found***' ) : ]

    if len( out ) < 2:
        if log10( n ) > 40:
            raise ValueError( 'yafu seems to have crashed trying to factor ' + str( int( n ) ) +
                              '.\n\nyafu output follows:\n' + full_out )
        else:
            debugPrint( 'yafu seems to have crashed, switching to built-in factoring code' )
            from rpn.factorise import factorise
            return factorise( int( n ) )

    result = [ ]

    while True:
        prime = ''

        out = out[ out.find( 'P' ) : ]

        if len( out ) < 2:
            break

        out = out[ out.find( '=' ) : ]

        index = 2

        while out[ index ] >= '0' and out[ index ] <= '9':
            prime += out[ index ]
            index += 1

        result.append( mpmathify( prime ) )

    if not result:
        raise ValueError( 'yafu seems to have failed.' )

    answer = fprod( result )

    if answer != n:
        debugPrint( '\nyafu has barfed' )
        for i in result:
            n = fdiv( n, i )

        result.extend( runYAFU( n ) )

    return sorted( result )