Example #1
0
 def next(self, quantum=1):
     "State after quantum."
     self.time += quantum
     avspeed = (2 * self.speed + self.h_acc * quantum) / 2
     avclimb = (2 * self.climb + self.v_acc * quantum) / 2
     self.alt += avclimb * quantum
     self.speed += self.h_acc * quantum
     self.climb += self.v_acc * quantum
     distance = avspeed * quantum
     # Formula from <http://williams.best.vwh.net/avform.htm#Rhumb>
     # Initial point cannot be a pole, but GPS doesn't work at high.
     # latitudes anyway so it would be OK to fail there.
     # Seems to assume a spherical Earth, which means it's going
     # to have a slight inaccuracy rising towards the poles.
     # The if/then avoids 0/0 indeterminacies on E-W courses.
     tc = gps.Deg2Rad(self.course)
     lat = gps.Deg2Rad(self.lat)
     lon = gps.Deg2Rad(self.lon)
     lat += distance * math.cos(tc)
     dphi = math.log(math.tan(lat / 2 + math.pi / 4)
                     / math.tan(self.lat / 2 + math.pi / 4))
     if abs(lat - self.lat) < math.sqrt(1e-15):
         q = math.cos(self.lat)
     else:
         q = (lat - self.lat) / dphi
     dlon = -distance * math.sin(tc) / q
     self.lon = gps.Rad2Deg(math.mod(lon + dlon + math.pi, 2 * math.pi)
                            - math.pi)
     self.lat = gps.Rad2Deg(lat)
Example #2
0
 def next(self, quantum=1):
     "State after quantum."
     self.time += quantum
     avspeed = (2 * self.speed + self.h_acc * quantum) / 2
     avclimb = (2 * self.climb + self.v_acc * quantum) / 2
     self.alt += avclimb * quantum
     self.speed += self.h_acc * quantum
     self.climb += self.v_acc * quantum
     distance = avspeed * quantum
     # Formula from <http://williams.best.vwh.net/avform.htm#Rhumb>
     # Initial point cannot be a pole, but GPS doesn't work at high.
     # latitudes anyway so it would be OK to fail there.
     # Seems to assume a spherical Earth, which means it's going
     # to have a slight inaccuracy rising towards the poles.
     # The if/then avoids 0/0 indeterminacies on E-W courses.
     tc = gps.Deg2Rad(self.course)
     lat = gps.Deg2Rad(self.lat)
     lon = gps.Deg2Rad(self.lon)
     lat += distance * math.cos(tc)
     dphi = math.log(
         math.tan(lat / 2 + math.pi / 4) /
         math.tan(self.lat / 2 + math.pi / 4))
     if abs(lat - self.lat) < math.sqrt(1e-15):
         q = math.cos(self.lat)
     else:
         q = (lat - self.lat) / dphi
     dlon = -distance * math.sin(tc) / q
     self.lon = gps.Rad2Deg(
         math.mod(lon + dlon + math.pi, 2 * math.pi) - math.pi)
     self.lat = gps.Rad2Deg(lat)
Example #3
0
def get_percent(value, max_value):
    """
    Ritorna un numero che rappresenta la percentuale del valore passato
    rispetto al suo potenziale massimo.
    """
    if max_value == 0:
        log.bug("max_value non è un parametro valido: 0")
        return 0

    # -------------------------------------------------------------------------

    if value > 0 and max_value < 0:
        max_value = math.mod(max_value)
        return 100 + ((value * 100) / max_value)
    elif value < 0 and max_value < 0:
        value = math.mod(value)
        max_value = math.mod(max_value)
        return -((value * 100) / max_value)
    else:
        return (value * 100) / max_value
Example #4
0
def get_percent(value, max_value):
    """
    Ritorna un numero che rappresenta la percentuale del valore passato
    rispetto al suo potenziale massimo.
    """
    if max_value == 0:
        log.bug("max_value non è un parametro valido: 0")
        return 0

    # -------------------------------------------------------------------------

    if value > 0 and max_value < 0:
        max_value = math.mod(max_value)
        return 100 + ((value * 100) / max_value)
    elif value < 0 and max_value < 0:
        value = math.mod(value)
        max_value = math.mod(max_value)
        return -((value * 100) / max_value)
    else:
        return (value * 100) / max_value
Example #5
0
    def get_data(self, offset = 0, length = None):
        # need to add a check to make sure offset and length are within limits
        #offset >= 0
        #offset + length <= len(self.inodes) * self.blocklayer.blocksize

        blocks = self.get_block_ids_for_byte_range(offset, length)
        data = b''
        for block_idx in blocks:
            block = self.blocklayer.read_block(block_idx)
            data += block
            
        # cut off data to match byte offsets
        start_offset = math.mod(offset / self.blocklayer.blocksize)
        if(length <> None):
            end_offset = self.blocklayer.blocksize - math.mod(length / self.blocklayer.blocksize)
        else:
            end_offset = len(data)

        data = data[start_offset:end_offset]
        return(data)
def plot_accuracy(chunk_accuracy_list):
    avg_chunk_accuracy = []
    n = 5
    sum1 = 0
    for i in range(1, len(chunk_accuracy_list)):
        sum1 = sum1 + chunk_accuracy_list[i - 1]
        if math.mod(i, n) == 0:
            avg_chunk_accuracy.append(sum1 / n)
            sum1 = 0

    x = range(1, len(avg_chunk_accuracy) + 1)
    # x=range(1,len(chunk_accuracy_list)+1,1000)
    mp.pyplot.plot(x, avg_chunk_accuracy)
    mp.pyplot.show()
def simpsons(x,h,N):
#Performs the Simpons rule (equation 1.12)
#Input:  x -- lower bound of the range of integration
#        h -- step-size
#        N -- number of lattices
#Output: sum -- approximate integral
 
#Add the contribution from the first and last points on the lattice points
    sum = myFunction(x) + myFunction(x+N*h)
    for i+1 in N-1:
    j = i+1
#Adds the contribution from the even placed lattice points        
        if (math.mod(j,2) == 1)
            sum = sum + 4.0*myFunction(x+j*h)
#Adds the contribution from the odd placed lattice points            
        else 
            sum = sum + 2.0*myFunction(x+j*h)        
    sum = sum*h/3                       #Apply leading coeffecient
    return sum
Example #8
0
def mkfs(blocklayer):
    r"""
    new blocklayer with 100 4k blocks
    >>> from blocklayer import ram_blocklayer 
    >>> bl = ram_blocklayer(100)
    >>> mkfs(bl)
    """
    
    # 0 superblock
    # 1 first inodeblock
    # 2 root dir
    # 3 fs meta
    
    if(math.mod(bs / ctypes.sizeof(INODE))):
        logger.warn('blocksize is not a multiple of inodesize, space will be wasted and a lot of warnings will be thrown')
    bs = blocklayer.blocksize
    for x in range(10):
        blocklayer.trim_block(x)
    sb = blocklayer.read_block(0)
    ib = Inodeblock(count = math.floor(bs / ctypes.sizeof(INODE)))    
    ib[0]
Example #9
0
 def mod(self):
     self.result = False
     self.current = math.mod(math.radians(float(txtDisplay.get())))
     self.display(self.current)