def generic_consend_test(server, port):
s = socket()
data = Buffer("hello world")
s.connect((server, port))
data.make_buffer_sendable()
s.send(data.get_buf())
s.close()
def emulated_sleep(time_slice, direction):
global active
active = True
global current_dir
current_dir = direction
global kill_flag
kill_flag = False
Buffer.set(direction)
start = time.time()
while not kill_flag:
stop = time.time()
if stop - start >= time_slice:
break
stop = time.time()
run_time = stop - start
print('Served time:', int(run_time), 'seconds')
global rem_time
global rem_dir
if run_time + 5 < time_slice:
rem_time = time_slice - run_time
rem_dir = direction
global emergency
emergency = False
active = False
def __init__(self, settings, input_stream=None, output_stream=None):
self.settings = settings
self.input_stream = input_stream
self.output_stream = output_stream
self.carr_buffer = Buffer.Buffer(self.settings.CHUNK)
self.mod_buffer = Buffer.Buffer(self.settings.CHUNK)
self.output_buffer = Buffer.Buffer(self.settings.CHUNK)
self.carrier_threshold = -40
def __init__(self):
self.relations = {}
self.selection_algorithms = ['scanning', 'binary', 'indexed']
self.buf_size = 512
self.blk_size = 64
self.buffer = Buffer(self.buf_size, self.blk_size)
self.tree = ''
self.routing_table_join = {'nested_loop_join', 'sort_merge_join', 'hash_join'}
def drop_table(table_name: str):
time_start = time.time()
Catalog.not_exists_table(table_name)
Catalog.drop_table(table_name)
Buffer.drop_table(table_name)
Index.delete_table(table_name)
time_end = time.time()
print("Successfully drop table '%s', time elapsed : %fs." %
(table_name, time_end - time_start))
def create_table(table_name: str, attributes: list, pk: str):
time_start = time.time()
Catalog.exists_table(table_name)
Index.create_table(table_name)
Catalog.create_table(table_name, attributes, pk)
Buffer.create_table(table_name)
time_end = time.time()
print("Successfully create table '%s', time elapsed : %fs." %
(table_name, time_end - time_start))
def run(self):
global barrier
print "Starting " + self.name
#Init the packet
UDP_IP_RX = "192.168.240.3"
UDP_IP_TX = "192.168.240.1"
UDP_PORT = 30444
MESSAGE1 = "Calling HTPA series devices"
MESSAGE2 = "Bind HTPA series device"
MESSAGE3 = "M"
MESSAGE4 = "k"
MESSAGE5 = "t"
MSG = [MESSAGE1,MESSAGE2,MESSAGE3,MESSAGE4,MESSAGE5]
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock.bind((UDP_IP_RX, UDP_PORT))
sock.settimeout(0.25)
data = []
buffer = []
i = 0
while True:
try:
data = sock.recv(2048) # buffer size is 1024 bytes
except:
data = []
if len(data) != 0 :
#print "received message len:", len(data)
if len(data) == 1058 :
buffer = data
elif len(data) == 1054:
buffer = buffer + data
buffer = swap(listReduce(buffer))
Buffer.setBuffer(buffer)
print "Grid", len(buffer)
print buffer[0]
barrierLock.acquire()
barrier = True
barrierLock.release()
elif len(data) < 1000 :
print "received message len:", len(data)
print "received message :", data
else :
if i < len(MSG):
print "Sending message:", MSG[i]
sock.sendto(MSG[i], (UDP_IP_TX, UDP_PORT))
i = i + 1
time.sleep(1)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
dissolve = self.getParameterValue(self.DISSOLVE)
field = self.getParameterValue(self.FIELD)
segments = int(self.getParameterValue(self.SEGMENTS))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs())
buff.buffering(progress, writer, 0, field, True, layer, dissolve,
segments)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
dissolve = self.getParameterValue(self.DISSOLVE)
field = self.getParameterValue(self.FIELD)
segments = int(self.getParameterValue(self.SEGMENTS))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs())
buff.buffering(progress, writer, 0, field, True, layer, dissolve,
segments)
def makeStars():
starPoints = []
for i in range(3 * globs.numStars):
starPoints.append(random.uniform(-1, 1))
buff = Buffer(array.array("f", starPoints))
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
starVao = tmp[0]
glBindVertexArray(starVao)
buff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, False, 3 * 4, 0)
glBindVertexArray(0)
return starVao
def put_code(self, output):
code = output['utility_code_def']
proto = output['utility_code_proto']
proto.put(Buffer.dedent("""\
static __Pyx_memviewslice %s(const __Pyx_memviewslice from_mvs); /* proto */
""" % self.copy_func_name))
copy_contents_name = get_copy_contents_name(self.from_memview, self.to_memview)
if self.to_memview.is_c_contig:
mode = 'c'
contig_flag = memview_c_contiguous
elif self.to_memview.is_f_contig:
mode = 'fortran'
contig_flag = memview_f_contiguous
C = dict(
context,
copy_name=self.copy_func_name,
mode=mode,
sizeof_dtype="sizeof(%s)" % self.from_memview.dtype.declaration_code(''),
contig_flag=contig_flag,
copy_contents_name=copy_contents_name
)
_, copy_code = TempitaUtilityCode.load_as_string(
"MemviewSliceCopyTemplate",
from_file="MemoryView_C.c",
context=C)
code.put(copy_code)
def startChatTo(self, username):
addr = self.requestPort(username)
if addr is None:
return False
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
buff = Buffer.Buffer(self.lock)
if username in self.message_list_dict:
service = Service_client.Service_client(
s,
buff,
self.message_list_dict[username],
self.username,
peer=username,
ip=self.ip)
self.buff_dict[username] = service.buffer
else:
message_list = GUII.Message_list(self.chatui.Message_box_frame)
service = Service_client.Service_client(s,
buff,
message_list,
self.username,
peer=username,
ip=self.ip)
self.buff_dict[username] = service.buffer
self.message_list_dict[username] = service.message_list
print(addr)
service.connectTo(addr)
service.start()
self.chatui.update()
return True
def put_code(self, output):
code = output['utility_code_def']
proto = output['utility_code_proto']
proto.put(
Buffer.dedent("""\
static __Pyx_memviewslice %s(const __Pyx_memviewslice from_mvs); /* proto */
""" % self.copy_func_name))
copy_contents_name = get_copy_contents_name(self.from_memview,
self.to_memview)
if self.to_memview.is_c_contig:
mode = 'c'
contig_flag = memview_c_contiguous
elif self.to_memview.is_f_contig:
mode = 'fortran'
contig_flag = memview_f_contiguous
C = dict(context,
copy_name=self.copy_func_name,
mode=mode,
sizeof_dtype="sizeof(%s)" %
self.from_memview.dtype.declaration_code(''),
contig_flag=contig_flag,
copy_contents_name=copy_contents_name)
_, copy_code = UtilityCode.load_as_string("MemviewSliceCopyTemplate",
from_file="MemoryView_C.c",
context=C)
code.put(copy_code)
def main():
""""
Test functionality
"""
_buffer_ = Buffer.Buffer(4)
threads = []
for i in range(3):
_aux_ = Producer.Producer(_buffer_)
threads.append(_aux_)
for i in range(5):
_aux_ = Consumer.Consumer(30, _buffer_)
threads.append(_aux_)
for i in range(8):
threads[i].start()
for i in range(8):
threads[i].join()
Consumer.Consumer._ans_.sort(key=lambda x: x[1])
print map(lambda x: x[0], Consumer.Consumer._ans_)
print _buffer_._check_ans_
def insert(table_name: str, values: list):
time_start = time.time()
Catalog.not_exists_table(table_name)
Catalog.check_types_of_table(table_name, values)
linenum = Buffer.insert_record(table_name, values)
Index.insert_into_table(table_name, values, linenum)
time_end = time.time()
print(" time elapsed : %fs." % (time_end - time_start))
def main():
# Read the inputs from the file
buf_size, num_pkts, packets = read_input('./testcases.txt')
# Create the packet buffer
buffer = Buffer.Buffer(buf_size)
# Process the packets
process_packets(buffer, packets)
def readBlob(self, fp, name):
line = fp.readline().decode()
assert line.startswith(name)
lst = line.split()
numbytes = int(lst[1])
blob = fp.read(numbytes)
fp.readline()
B = Buffer(blob)
return B
def delete(table_name: str, where: list = None):
time_start = time.time()
Catalog.not_exists_table(table_name)
Catalog.check_select_statement(table_name, ['*'], where) # 从insert中借用的方法
col = Catalog.get_column_dic(table_name)
pklist = Buffer.delete_record(table_name, col, where)
Index.delete_from_table(table_name, pklist)
time_end = time.time()
print(" time elapsed : %fs." % (time_end - time_start))
def getBlob(self, fp, tag):
line = fp.readline().decode()
lst = line.split()
assert lst[0] == tag
numbytes = int(lst[1])
B = fp.read(numbytes)
buf = Buffer(B)
fp.readline() # discard empty line
return buf
def main():
global ROW
global COLUMN
Buffer.initBuffer(ROW * COLUMN)
grid = Grid(ROW,COLUMN)
Udp.init()
app = wx.App()
frame = wx.Frame(None, -1, 'TestFrame.py')
box = Box(frame, -1, grid, grid.updateBuffer)
box.timer.Start(10) # Frame Rate 5 miliseconds
box.Draw(grid,X_COORD,Y_COORD,BOX_WIDTH,BOX_HEIGHT)
frame.Show(True)
app.MainLoop()
def bindVao(vArray, iArray=None):
vBuff = Buffer.Buffer(vArray)
# GenerateVAO
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
vao = tmp[0]
glBindVertexArray(vao)
# Tell GL about buffer layout and use the buffer
# Bind index buffer to point at vertexbuffers indicies if available
if iArray != None and len(iArray) != 0:
ibuff = Buffer.Buffer(iArray)
ibuff.bind(GL_ELEMENT_ARRAY_BUFFER)
vBuff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
# which pipe, items per vertex, type per item, auto-normalize, data size per item in bytes, start in buffer
# numPoints = len(arrayOfPoints)
glVertexAttribPointer(0, 2, GL_FLOAT, False, 2 * 4, 0)
def __init__(self, sizeOfBuffer, numberOfCores, numberOfThreads,
timeQuantum, contextSwitchTime):
Buffer.Buffer.initBufferCount()
self.buffer = Buffer.Buffer(sizeOfBuffer)
self.numberOfCores = numberOfCores
self.cores = []
for y in list(range(numberOfCores)):
self.cores.append(Core.Core(y, 0))
self.threadPool = ThreadPool.ThreadPool(numberOfThreads)
self.timeQuantum = timeQuantum
self.contextSwitchTime = contextSwitchTime
def setupUniforms(prog):
tmp = array.array("I", [0])
glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, tmp)
numuniforms = tmp[0]
uniformsToQuery = array.array("I", range(numuniforms))
offsets = array.array("I", [0] * numuniforms)
sizes = array.array("I", [0] * numuniforms)
types = array.array("I", [0] * numuniforms)
glGetActiveUniformsiv(prog, numuniforms, uniformsToQuery,
GL_UNIFORM_OFFSET, offsets)
glGetActiveUniformsiv(prog, numuniforms, uniformsToQuery,
GL_UNIFORM_SIZE, sizes)
glGetActiveUniformsiv(prog, numuniforms, uniformsToQuery,
GL_UNIFORM_TYPE, types)
sizeForType = {
GL_FLOAT_VEC4: 4 * 4,
GL_FLOAT_VEC3: 3 * 4,
GL_FLOAT_VEC2: 2 * 4,
GL_FLOAT: 1 * 4,
GL_INT: 1 * 4,
GL_FLOAT_MAT4: 4 * 16,
GL_FLOAT_MAT3: 3 * 16,
GL_FLOAT_MAT2: 2 * 16
}
nameBytes = bytearray(256)
Program.totalUniformBytes = 0
for i in range(numuniforms):
glGetActiveUniformName(prog, i, len(nameBytes), tmp, nameBytes)
nameLen = tmp[0]
name = nameBytes[:nameLen].decode()
if offsets[i] != 0xffffffff:
assert sizes[i] == 1 or types[i] == GL_FLOAT_VEC4
numBytes = sizeForType[types[i]] * sizes[i]
Program.uniforms[name] = (offsets[i], numBytes, types[i],
sizes[i])
end = offsets[i] + numBytes
if end > Program.totalUniformBytes:
Program.totalUniformBytes = end
#create_string_buffer is inside the ctypes package
Program.uboBackingMemory = create_string_buffer(
Program.totalUniformBytes)
#addressof is from ctypes too
Program.uboBackingAddress = addressof(Program.uboBackingMemory)
Program.ubo = Buffer(data=None,
size=Program.totalUniformBytes,
usage=GL_DYNAMIC_DRAW)
Program.ubo.bindBase(GL_UNIFORM_BUFFER, 0)
def setup(pointArray):
glEnable(GL_MULTISAMPLE)
glClearColor(0, 0, 0, 1.0)
my_buffer = Buffer(pointArray)#array.array("f", [0, 0]))
# GenerateVAO
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
vao = tmp[0]
glBindVertexArray(vao)
# Tell GL about buffer layout and use the buffer
my_buffer.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
# which pipe, items per vertex, type per item, auto-normalize, data size per item in bytes, start in buffer
# numPoints = len(arrayOfPoints)
glVertexAttribPointer(0, 2, GL_FLOAT, False, 2 * 4, 0)
# unbind
# glBindVertexArray(0)
prog = Program("vs.txt", "fs.txt")
prog.use()
def RunSatellite():
# Add the FOR loops first
buffer = Buffer.Buffer(10)
buff = buffer.getBuffer()
satellie = Satellite.Satellite(buff, 10)
satellie.start()
satellie.join()
receiver = Receiver.Receiver(buff, 10)
receiver.start()
receiver.join()
def __init__(self, fontname, size):
if Text.prog == None:
Text.prog = Program("TextVertexShader.txt",
"TextFragmentShader.txt")
self.txt = "temp"
self.samp = Sampler()
self.font = TTF_OpenFont(
os.path.join("assets", fontname).encode(), size)
open(os.path.join("assets", fontname))
vbuff = Buffer(array.array("f", [0, 0, 1, 0, 1, 1, 0, 1]))
ibuff = Buffer(array.array("I", [0, 1, 2, 0, 2, 3]))
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
self.vao = tmp[0]
glBindVertexArray(self.vao)
ibuff.bind(GL_ELEMENT_ARRAY_BUFFER)
vbuff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 2, GL_FLOAT, False, 2 * 4, 0)
glBindVertexArray(0)
self.tex = DataTexture2DArray(1, 1, 1, array.array("B", [0, 0, 0, 0]))
self.textQuadSize = vec2(0, 0)
self.pos = vec2(0, 0)
self.dirty = False
surf1p = TTF_RenderUTF8_Blended(self.font, self.txt.encode(),
SDL_Color(255, 255, 255, 255))
surf2p = SDL_ConvertSurfaceFormat(surf1p, SDL_PIXELFORMAT_ABGR8888, 0)
w = surf2p.contents.w
h = surf2p.contents.h
pitch = surf2p.contents.pitch
if pitch != w * 4:
print("Uh Oh!", pitch, w)
pix = surf2p.contents.pixels
B = string_at(pix, pitch * h)
self.tex.setData(w, h, 1, B)
SDL_FreeSurface(surf2p)
SDL_FreeSurface(surf1p)
self.textQuadSize = vec2(w, h)
self.dirty = False
Program.setUniform("textPosInPixels", self.pos)
Program.setUniform("textQuadSizeInPixels", self.textQuadSize)
Program.updateUniforms()
def select(table_name: str, attributes: list, where: list = None):
time_start = time.time()
Catalog.not_exists_table(table_name)
Catalog.check_select_statement(table_name, attributes, where)
#Index.select_from_table(table_name, attributes, where)
col_dic = Catalog.get_column_dic(table_name)
results = Buffer.find_record(table_name, col_dic, where)
numlist = []
if attributes == ['*']:
attributes = list(col_dic.keys())
numlist = list(col_dic.values())
else:
for att in attributes:
numlist.append(col_dic[att])
print_select(attributes, numlist, results)
time_end = time.time()
print(" time elapsed : %fs." % (time_end - time_start))
def __init__(self, fontname, size):
if Text.prog == None:
Text.prog = Program("textvs.txt", "textfs.txt")
TTF_Init()
self.font = TTF_OpenFont(
os.path.join("assets", fontname).encode(), size)
vbuff = Buffer(array.array("f", [0, 0, 1, 0, 1, 1, 0, 1]))
ibuff = Buffer(array.array("I", [0, 1, 2, 0, 2, 3]))
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
self.vao = tmp[0]
glBindVertexArray(self.vao)
ibuff.bind(GL_ELEMENT_ARRAY_BUFFER)
vbuff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 2, GL_FLOAT, False, 2 * 4, 0)
glBindVertexArray(0)
self.tex = DataTexture2DArray(1, 1, 1, array.array("B", [0, 0, 0, 0]))
self.textQuadSize = vec2(0, 0)
self.pos = vec2(0, 0)
self.dirty = False
def recv_traffic(self):
print "Receiving client: ",str(self.client.getpeername())
current_length = 0
data_buf = Buffer()
while self.listen and self.client:
try:
self.conn_lock.acquire()
#print "Looping...."
# will read the initial packet
if current_length > 0:
t = self.client.recv(current_length)
current_length -= len(t)
data_buf.append(t)
elif current_length == 0:
# clear buffer and wait
# for new pkt
#print "Data buffer was reset, recv'ing a new buf"
data_buf.append(self.client.recv(4))
current_length = data_buf.read_int() - 4
print "Recieved the current length %x"%(current_length+4)
if current_length == 0 and len(data_buf) > 0:
print "Handling the following pkt: %s"%(repr(data_buf.get_buf()))
self.handle_recv(data_buf)
data_buf = Buffer()
self.conn_lock.release()
except timeout:
if self.conn_lock.locked():
self.conn_lock.release()
print "Timeout occured on the client"
pass
except Exception, e:
if self.conn_lock.locked():
self.conn_lock.release()
if str(sys.exc_info()[1]).find("Errno 10035") > -1:
pass
else:
print "Exception Type: %s"%(str(sys.exc_info()[0]))
print "Exception Message: %s"%(str(sys.exc_info()[1]))
raise e
def listen_run(self):
self.listen_socket.listen()
while self.listen_flag:
print('accept1')
conn, addr = self.listen_socket.accept()
if self.listen_flag:
buff = Buffer.Buffer(self.lock)
message_list = GUII.Message_list(self.chatui.Message_box_frame)
service = Service_client.Service_client(conn,
buff,
message_list,
self.username,
ip=self.ip)
self.buff_dict[service.peer] = service.buffer
if service.peer in self.message_list_dict:
service.message_list = self.message_list_dict[service.peer]
else:
self.message_list_dict[service.peer] = service.message_list
self.chatui.update()
service.start()
print('closed')
def evaluate(clientsocket, addr):
print "Visualisation connected"
BufferList = Buffer.PiBuffer()
while True:
time.sleep(2)
try:
evaluatedlist = scannedData.evaluateAll()
for x in range(len(evaluatedlist)): # where the server thinks the phones are from raw data
message = evaluatedlist[x][0] + "," + PiList[evaluatedlist[x][1][0]] + ","
#print message
BufferList.addtobuffer(evaluatedlist[x][0], PiList[evaluatedlist[x][1][0]]) # put the data into a buffer , so it can be processed further
for x in BufferList.evaluate():
finalmessage = x[0] + "," + x[1] + "," # and this function returns the mode
clientsocket.send(finalmessage) #of those (so 1 rogue data cant go out)
time.sleep(1) #my vizualization needs time to process
scannedData.clearList()
time.sleep(0.2)
except IndexError:
pass
def initialize(path: str):
Catalog.__initialize__(path)
Index.__initialize__(path)
Buffer.__initialize__()
def generic_interact_test(server, port):
s = socket()
data = Buffer("hello there\n")
data.make_buffer_sendable()
print hex(len(data.get_buf())), hex(data.read_int()),data.get_buf()
s.connect((server, port))
s.send(data.get_buf())
data.reset()
data.append("Do you have and Grey Poupon?\n")
data.make_buffer_sendable()
print hex(len(data.get_buf())), hex(data.read_int()),data.get_buf()
s.send(data.get_buf())
buf = s.recv(65535)
print buf
bufs = input("Enter a response")
s.send(bufs)
s.close()
def save():
Catalog.__finalize__()
Index.__finalize__()
Buffer.__finalize__()
print("All tables have been saved.")
def mangle_dtype_name(dtype):
# a dumb wrapper for now; move Buffer.mangle_dtype_name in here later?
import Buffer
return Buffer.mangle_dtype_name(dtype)
def makeSquare(xsz, ysz, flipTextureY):
vbuff = Buffer(
array.array("f", [-xsz, -ysz, xsz, -ysz, xsz, ysz, -xsz, ysz]))
if flipTextureY:
tbuff = Buffer(array.array("f", [0, 1, 1, 1, 1, 0, 0, 0]))
else:
tbuff = Buffer(array.array("f", [0, 0, 1, 0, 1, 1, 0, 1]))
ibuff = Buffer(array.array("I", [0, 1, 2, 0, 2, 3]))
tmp = array.array("I", [0])
glGenVertexArrays(1, tmp)
vao = tmp[0]
glBindVertexArray(vao)
ibuff.bind(GL_ELEMENT_ARRAY_BUFFER)
vbuff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 2, GL_FLOAT, False, 2 * 4, 0)
tbuff.bind(GL_ARRAY_BUFFER)
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 2, GL_FLOAT, False, 2 * 4, 0)
glBindVertexArray(0)
return vao
def __init__(self,fichero): self.__counter=0 self.__bottom=Bottom(0x00); self.__top=Top(0xFF); self.__bits=Buffer(fichero)
class Extreme_Interval():
def __init__(self,fichero):
self.__counter=0
self.__bottom=Bottom(0x00);
self.__top=Top(0xFF);
self.__bits=Buffer(fichero)
def __Is_underflow(self):
return self.__top[:2]=="10" and self.__bottom[:2]=="01"
# if self.__top>9 and self.__bottom>9:
# First_digit_top=self.__top/first_digit_base
# First_digit_bottom=self.__bottom/first_digit_base
# print self.__top
# print self.__bottom
# print "primer digito top: ",First_digit_top
# print "primer digito bottom",First_digit_bottom
# dif_in_one= (First_digit_top-First_digit_bottom)==1
# if dif_in_one: print "ES VERDAD"
# top_list=",".join(str(self.__top))
# top_list=top_list.split(",")
# Second_digit_top=int(top_list[1])
# bottom_list=",".join(str(self.__bottom))
# bottom_list=bottom_list.split(",")
# Second_digit_bottom=int(bottom_list[1])
# if len(top_list)==len(bottom_list):
# return Second_digit_top==0 and Second_digit_bottom==9 and dif_in_one
# return False
def __Get_list(self,number):
string=",".join(str(number))
return string.split(",")
# def __Shift_extremes(self):
# top_list=self.__Get_list(self.__top)
# bottom_list=self.__Get_list(self.__bottom)
# del top_list[1]
# del bottom_list[1]
# top_list.append("9")
# bottom_list.append("0")
# self.__top=int("".join(top_list))
# self.__bottom=int("".join(bottom_list))
def __Process_Underflow(self):
while self.__top.Is_Underflow(self.__bottom):
# print "UNDERFLOW!!!!!!!"
self.__counter+=1;
self.__shift()
def __shift(self):
self.__top<<1
self.__bottom<<1
# if bit_bot==1:
# self.__bottom-=0x80
# self.__top-=0x80
# self.__bottom*=2
# self.__top*=2
# self.__top+=1
def __Store_Partial_result(self):
# bit_bot=self.__bottom/base_one_MSB;
# bit_top=self.__top/base_one_MSB;
while self.__top[0]==self.__bottom[0]:
# print "bit bot ",bit_bot
# if bit_bot==0: print "SON CERO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
self.__bits.append(chr(ord("0")+int(self.__top[0])))
bit_complement=int(bin(~int(self.__top[0]))[-1])
for i in range(self.__counter):
self.__bits.append(chr(ord("0")+bit_complement))
self.__counter=0
# print "corro 1 lugar"
self.__shift()
# print "top: ",int(self.__top)
# print "bottom: ",int(self.__bottom)
def Get_length(self):
return int(self.__top)-int(self.__bottom)
def Get_Top(self):
return int(self.__top)
def Get_Bottom(self):
return int(self.__bottom)
def Set_extremes(self,bottom,top):
self.__bottom.Set_value(bottom)
self.__top.Set_value(top)
def update_bottom(self,value):
# print "Antes... bottom: ",int(self.__bottom)
# print value
self.__bottom+=int(value)
# print "Despues... bottom: ",int(self.__bottom)
def update_top(self,my_distance):
# print "Antes... top: ",int(self.__top)
# print "Distancia: ",my_distance
# print "bottom + distancia: =",int(self.__bottom)+int(my_distance)
self.__top.Set_value(int(self.__bottom)+ int(my_distance))
# print "Despues... top: ",int(self.__top)
def normalizate(self):
# print "top: ",int(self.__top)
# print "bottom: ",int(self.__bottom)
self.__Process_Underflow();
self.__Store_Partial_result();
def All_data_stored(self):
return self.__bits.All_data_stored();
def Bit_padding(self):
self.__bits.Bit_padding()
