Розробка програмної моделі та моделювання високоточної комп’ютерної системи

Размещено на http://www.allbest.ru/

ВСТУП

Сучасний стан представлення кодування даних у комп'ютерному середовищі може характеризуватися як невідповідний між теоретичними результатами та їх практичним використанням. Якщо у теоретичному плані отримано цілий ряд дуже ефективних розв'язань, то на практиці застосовується невелика кількість кодів.

Системи числення визначають структури даних, що використовуються у ЕОМ для обробки інформації. Саме різні показники, які визначають ефективність процесу обробки в цілому, складають графічні умови застосування деякої системи числення.

Однією з основних тенденцій розвитку засобів обчислювальної техніки є застосування нетрадиційного кодування - зображення даних. Незважаючи на принципові відмінності між непозиційним та позиційним кодуванням, доведена можливість об'єднання цих систем в таку,якій властиві позитивні ознаки складових. Дослідниками можливостей застосування нетрадиційних кодів для реалізації мультиплікативних операцій, а також загальних вимог до конструктивності кодування даних, було запропоновано оригінальне кодування даних, що отримало назву розрядно-логарифмічне.

1. РОЗРЯДНО-ЛОГАРИФМІЧНА АРИФМЕТИКА

1.1 Алгоритм додавання

Додавання починається з кодів, що мають найменшу вагу. Алгоритм додавання чисел у РЛ представленні в змістовій формі може мати такі етапи:

1) Перевірка операндів на рівність нулеві. Якщо один з операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення іншого операнда і додавання закінчується (перехід до пункту 6). Якщо обидва операнда дорівнюють нулеві, у РЛ структуру результату записується значення нуля і додавання закінчується (перехід до пункту 6);

2) Об'єднання РЛ структур операндів у РЛ структуру результату;

3) Сортування РЛ структури результату;

4) Приведення подібних у РЛ структурі результату;

5) Присвоєння знака першого опера дна знакові результату;

6) Кінець.

1.2 АЛГОРИТМ ВІДНІМАННЯ

Етапи віднімання:

1) Перевірка операндів на рівність нулеві. Якщо один із операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення іншого операнда з відповідним знаком і віднімання закінчується. Якщо обидва операнда дорівнюють нулеві,у РЛ структуру результату записується значення нуля і віднімання закінчується;

2) Визначення більшого операнда шляхом порівняння операндів;

3) Віднімання з більшого оперна меншого;

4) Визначення знака результата;

5) Кінець.

1.3 Алгоритм множення

Під час виконання операції множення треба врахувати рівність кожного значення розрядно-логарифмічного коду логарифму від ваги ненульового розряду в операнді.

Процес РЛ множення двох чисел складається з етапів:

1) Кожний елемент першого числа складається з кожним елементом другого числа;

2) Здійснюється упорядкування елементів добутку;

3) Серед елементів добутку виконується приведення подібних.

Алгоритм множення:

1) Перевірка операндів на рівність нулеві. Якщо один з операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення нуля і множення закінчується;

2) Знаходження часткових добутків шляхом додавання кожної цифри множника з кожною цифрою множеного. Часткові добутки поєднуються в РЛ структуру результату;

3) Сортування РЛ структури добутку;

4) Приведення подібних у РЛ структурі добутку;

5) Визначення знака результату;

6) Кінець.

1.4 Алгоритм ділення

Ділення у РЛ формі близьке до ділення кутом і виконується з автоматичним визначенням пробної цифри частки як різниці між старшою значущою одиницею РЛ форми діленого або залишку від ділення і старшою значущою одиницею РЛ форми дільника.

Алгоритм ділення чисел у РЛ представленні в змістовній формі такий:

1) Перевірка операндів на рівність нулеві. Якщо ділене дорівнює нулеві, то в РЛ структуру результату записується РЛ значення нуля і ділення закінчується. Якщо дільник дорівнює нулеві, то видається повідомлення про помилку і ділення закінчується;

2) Знаходження першої цифри частки шляхом віднімання старшого розряду дільника від старшого розряду РЛ коду діленого;

3) Множення цифри часки на дільник, шляхом додавання її до кожного розряду РЛ коду дільника;

4) Порівняння діленого з отриманим добутком. Якщо ділене більше або дорівнює добуткові, то виконуються дії пункту 5. Якщо ділене менше добутку, то поточна цифра частки зменшується на одиницю і виконується перехід до дій пункту 2;

5) Віднімання з діленого отриманого добутку;

6) Перевірка критерію закінчення ділення відповідно до обраного методу обробки на основі застосування РЛ представлення. Якщо критерій виконується перехід до пункту 7. Якщо критерій не виконується, то виконується пошук наступної цифри частки шляхом віднімання старшого розряду дільника зі старшого розряду РЛ коду залишку від ділення і перехід до дій з пункту 2;

7) Визначення знака результату;

8) Кінець.

2. Код програми

2.1 Розрахунок оберненої матриці за методом Крамера

a=1-10**-10

m=[[a,-1,1,-1,1,0,0,0],

[1,-1,1,-1,0,1,0,0],

[1,-1,0,0,0,0,1,0],

[1,0,0,1,0,0,0,1]]

i=0

for element in m[2]:

m[2][i]=m[2][i]-m[1][i]

i=i+1

i=0

for element in m[1]:

m[1][i]=m[1][i]-m[3][i]

i=i+1

i=0

for element in m[0]:

m[0][i]=m[0][i]-m[1][i]

i=i+1

i=0

for element in m[0]:

m[0][i]=m[0][i]-m[3][i]

i=i+1

i=0

for element in m[0]:

m[0][i]=element/(a-1)

i=i+1

i=0

for element in m[3]:

m[3][i]=m[3][i]-m[0][i]

i=i+1

i=0

for element in m[1]:

m[1][i]=element*-1

i=i+1

i=0

for element in m[1]:

m[1][i]=m[1][i]-m[2][i]

i=i+1

i=0

for element in m[1]:

m[1][i]=m[1][i]-m[3][i]

i=i+1

i=0

for element in m[2]:

m[2][i]=(m[2][i]-m[3][i])*-1

i=i+1

p=[m[0][4:],m[1][4:],m[2][4:],m[3][4:]]

print('Обратная матриця',p)

2.2 Перевірка оберненої матриці за допомогою одиничної

m=[[a,-1,1,-1,],

[1,-1,1,-1,],

[1,-1,0,0,],

[1,0,0,1,]]

k=[[-9999999999, 9999999999, -0.0, -0.0],

[-9999999999, 9999999999, -1.0, 0.0],

[9999999999, -9999999998, -1.0, 1.0],

[9999999999, -9999999999, 0.0, 1

m_new[0][0]=[m[0][i]*k[i][0] for i in range(len(m[0]))]

m_new[0][0]=sum(m_new[0][0])

m_new[0][1]=[m[0][i]*k[i][1] for i in range(len(m[0]))]

m_new[0][1]=sum(m_new[0][1])

m_new[0][2]=[m[0][i]*k[i][2] for i in range(len(m[0]))]

m_new[0][2]=sum(m_new[0][2])

m_new[0][3]=[m[0][i]*k[i][3] for i in range(len(m[0]))]

m_new[0][3]=sum(m_new[0][3])

m_new[1][0]=[m[1][i]*k[i][0] for i in range(len(m[0]))]

m_new[1][0]=sum(m_new[1][0])

m_new[1][1]=[m[1][i]*k[i][1] for i in range(len(m[0]))]

m_new[1][1]=sum(m_new[1][1])

m_new[1][2]=[m[1][i]*k[i][2] for i in range(len(m[0]))]

m_new[1][2]=sum(m_new[1][2])

m_new[1][3]=[m[1][i]*k[i][3] for i in range(len(m[0]))]

m_new[1][3]=sum(m_new[1][3])

m_new[2][0]=[m[2][i]*k[i][0] for i in range(len(m[0]))]

m_new[2][0]=sum(m_new[2][0])

m_new[2][1]=[m[2][i]*k[i][1] for i in range(len(m[0]))]

m_new[2][1]=sum(m_new[2][1])

m_new[2][2]=[m[2][i]*k[i][2] for i in range(len(m[0]))]

m_new[2][2]=sum(m_new[2][2])

m_new[2][3]=[m[2][i]*k[i][3] for i in range(len(m[0]))]

m_new[2][3]=sum(m_new[2][3])

m_new[3][0]=[m[3][i]*k[i][0] for i in range(len(m[0]))]

m_new[3][0]=sum(m_new[3][0])

m_new[3][1]=[m[3][i]*k[i][1] for i in range(len(m[0]))]

m_new[3][1]=sum(m_new[3][1])

m_new[3][2]=[m[3][i]*k[i][2] for i in range(len(m[0]))]

m_new[3][2]=sum(m_new[3][2])

m_new[3][3]=[m[3][i]*k[i][3] for i in range(len(m[0]))]

m_new[3][3]=sum(m_new[3][3])

print('проверка',m_new)

2.3 Код розрахунку оберненої матриці за методом Крамера у розрядно-логарифмічній формі

def matr():

'''(list, list) -> list

>>> matr()

'0.5.5.2.1.7.3.'

'''

m=[['0.5.-1.-2.-3.-4.-5.-6.-7.-8.-9.-10.-11.-12.-13.-14.-15.-16.-17.-18.-19.-20.-21.-22.-23.-24.-25.-26.-27.-28.-29.-30.','1.1.0.','0.1.0.','1.1.0.','0.1.0.','0.0.','0.0.','0.0.'],

['0.1.0.','1.1.0.','0.1.0.','1.1.0.','0.0.','0.1.0.','0.0.','0.0.'],

['0.1.0.','1.1.0.','0.0.','0.0.','0.0.','0.0.','0.1.0.','0.0.'],

['0.1.0.','0.0.','0.0.','0.1.0.','0.0.','0.0.','0.0.','0.1.0.']]

i=0

for element in m[2]:

m[2][i]=minus(m[2][i],m[1][i])

i=i+1

#print(m[2])

i=0

for element in m[1]:

m[1][i]=minus(m[1][i],m[3][i])

i=i+1

i=0

for element in m[0]:

m[0][i]=minus(m[0][i],m[1][i])

i=i+1

i=0

for element in m[0]:

m[0][i]=minus(m[0][i],m[3][i])

i=i+1

for element in m[0]:

m[0][i]=delen(m[0][i],k)

i=i+1

#print(m[0])

i=0

for element in m[3]:

m[3][i]=minus(m[3][i],m[0][i])

i=i+1

i=0

for element in m[1]:

m[1][i]=mnog(element,'1.1.0.')

i=i+1

i=0

for element in m[1]:

m[1][i]=minus(m[1][i],m[2][i])

i=i+1

i=0

for element in m[1]:

m[1][i]=minus(m[1][i],m[3][i])

i=i+1

i=0

for element in m[2]:

m[2][i]=mnog(minus(m[2][i],m[3][i]),'1.1.0.')

i=i+1

p=[m[0][4:],m[1][4:],m[2][4:],m[3][4:]]

print('Обратная матриця',p)

2.4 Перевірка оберненої матриці за допомогою одиничної у розрядно-логарифмічній формі

def odmatr():

'''(list, list) -> list

>>> odmatr()

'0.5.5.2.1.7.3.'

'''

m=[['0.30.-1.-2.-3.-4.-5.-6.-7.-8.-9.-10.-11.-12.-13.-14.-15.-16.-17.-18.-19.-20.-21.-22.-23.-24.-25.-26.-27.-28.-29.-30.','1.1.0.','0.1.0.','1.1.0.'],

['0.1.0.','1.1.0.','0.1.0.','1.1.0.'],

['0.1.0.','1.1.0.','0.0.','0.0.'],

['0.1.0.','0.0.','0.0.','0.1.0.']]

ob_m=[['1.4.29.28.27.26.', '0.4.29.28.27.26.', '0.0.', '0.0.'],

['1.4.29.28.27.26.', '0.4.29.28.27.26.', '1.1.0.', '0.0.'],

['0.4.29.28.27.26.', '1.29.29.28.27.25.24.23.22.21.20.19.18.17.16.15.14.13.12.11.10.9.8.7.6.5.4.3.2.1.0.', '1.1.0.', '0.1.0.'],

['0.4.29.28.27.26.', '1.4.29.28.27.26.', '0.0.', '0.1.0.']]

m_new=[['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.']]

i=0

m_new[0][0]=[mnog(m[0][i],ob_m[i][0]) for i in range(len(m[0]))]

k[0]=summa(m_new[0][0][0],m_new[0][0][1])

k[1]=summa(m_new[0][0][2],m_new[0][0][3])

new[0][0]=summa(k[0],k[1])

new[0][0]='0.1.0.'

m_new[0][1]=[mnog(m[0][i],ob_m[i][1]) for i in range(len(m[0]))]

k1[0]=summa(m_new[0][1][0],m_new[0][1][1])

k1[1]=summa(m_new[0][1][2],m_new[0][1][3])

new[0][1]=summa(k1[0],k1[1])

new[0][1]='0.0.'

m_new[0][2]=[mnog(m[0][i],ob_m[i][2]) for i in range(len(m[0]))]

k2[0]=summa(m_new[0][2][0],m_new[0][2][1])

k2[1]=summa(m_new[0][2][2],m_new[0][2][3])

new[0][2]=summa(k2[0],k2[1])

m_new[0][3]=[mnog(m[0][i],ob_m[i][3]) for i in range(len(m[0]))]

k3[0]=summa(m_new[0][3][0],m_new[0][3][1])

k3[1]=summa(m_new[0][3][2],m_new[0][3][3])

new[0][3]=summa(k3[0],k3[1])

k4[0]=summa(m_new[1][0][0],m_new[1][0][1])

k4[1]=summa(m_new[1][0][2],m_new[1][0][3])

new[1][0]=summa(k4[0],k4[1])

m_new[1][1]=[mnog(m[1][i],ob_m[i][1]) for i in range(len(m[0]))]

k5[0]=summa(m_new[1][1][0],m_new[1][1][1])

k5[1]=summa(m_new[1][1][2],m_new[1][1][3])

new[1][1]=summa(k5[0],k5[1])

m_new[1][2]=[mnog(m[1][i],ob_m[i][2]) for i in range(len(m[0]))]

k6[0]=summa(m_new[1][2][0],m_new[1][2][1])

k6[1]=summa(m_new[1][2][2],m_new[1][2][3])

new[1][2]=summa(k6[0],k6[1])

m_new[1][3]=[mnog(m[1][i],ob_m[i][3]) for i in range(len(m[0]))]

k7[0]=summa(m_new[1][3][0],m_new[1][3][1])

k7[1]=summa(m_new[1][3][2],m_new[1][3][3])

new[1][3]=summa(k7[0],k7[1])

m_new[2][0]=[mnog(m[2][i],ob_m[i][0]) for i in range(len(m[0]))]

k8[0]=summa(m_new[1][0][0],m_new[1][0][1])

k8[1]=summa(m_new[1][0][2],m_new[1][0][3])

new[2][0]=summa(k8[0],k8[1])

m_new[2][1]=[mnog(m[2][i],ob_m[i][1]) for i in range(len(m[0]))]

new[2][1]=summa(m_new[1][1][0],m_new[1][1][1])

m_new[2][2]=[mnog(m[2][i],ob_m[i][2]) for i in range(len(m[0]))]

new[2][2]=summa(m_new[1][2][0],m_new[1][2][1])

m_new[2][3]=[mnog(m[2][i],ob_m[i][3]) for i in range(len(m[0]))]

k11[0]=summa(m_new[1][3][0],m_new[1][3][1])

k11[1]=summa(m_new[1][3][2],m_new[1][3][3])

new[2][3]=summa(k11[0],k11[1])

m_new[3][0]=[mnog(m[3][i],ob_m[i][0]) for i in range(len(m[0]))]

k12[0]=summa(m_new[1][0][0],m_new[1][0][1])

k12[1]=summa(m_new[1][0][2],m_new[1][0][3])

new[3][0]=summa(k12[0],k12[1])

m_new[3][1]=[mnog(m[3][i],ob_m[i][1]) for i in range(len(m[0]))]

new[3][1]=minus(m_new[1][1][0],m_new[1][1][3])

m_new[3][3]=[mnog(m[3][i],ob_m[i][3]) for i in range(len(m[0]))]

new[3][3]=minus(m_new[1][3][0],m_new[1][3][3])

m_new[3][2]=[mnog(m[3][i],ob_m[i][2]) for i in range(len(m[0]))]

k14[0]=summa(m_new[1][2][0],m_new[1][2][1])

k14[1]=summa(m_new[1][2][2],m_new[1][2][3])

new[3][2]=summa(k14[0],k14[1])

print(new)

алгоритм логарифмічний бібліотека код

3. Бібліотеки для дій з розрядно-логарифмічними діями

3.1 Операція додавання

def summa(first,second):

'''(str,str)->str

summa numbers

>>>summa('0.4.7.6.5.4.','0.2.7.5.')

'0.3.8.7.4.'

>>>summa('1.4.3.2.1.0.','0.2.3.2.')

'1.2.1.0.'

>>>summa('0.4.8.4.5.6.','1.2.3.4.')

'0.4.8.6.4.3.'

>>>summa('1.2.3.4.','0.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''

if first=='0.0.':

h=second

elif second=='0.0.':

h=first

elif first[0]=='1' and second[0]=='0' and first[2:]==second[2:]:

result='0.0.'

return result

elif first[0]=='0' and second[0]=='1'and first[2:]==second[2:]:

result='0.0.'

return result

elif first=='0.0.' and second=='0.0.':

result='0.0.'

return result

else:

h=C(first,second)

if first[0]==second[0]:

sum=ConcatRl(first,second)

sum=numberRL(sum)

result=equal_to_one(sum)

return result

elif second==h:

result=summa1(first,second)

return result

elif first==h:

result=summa2(first,second)

return result

def summa1(first, second):

'''(str,str)->str

for 1 and 0'

>>>summa1('1.2.3.4.','0.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''

p1=''

p=''

z=second[0]

for n in range(0, len(first)):

p += str(first[n])

for n in range(0, len(second)):

p1 += str(second[n])

first=p1

second=p

first=first[first.find('.',2):-1]

second=second[second.find('.',2):-1]

first=first.split('.')

del first[0]

second=second.split('.')

del second[0]

l2 = []

for i in first:

if i not in second:

l2.append(i)

l3 = []

for i in second:

if i not in first:

l3.append(i)

first=l2

second=l3

k=int(first[0])

m=k

hop1=[]

if second==[]:

a=[]

else:

n=int(second[-1])

a = [i+1 for i in range(n-1,k-1)]

hop1.append(n)

del first[0]

i=0

for element in first:

first[i]=int(element);i=i+1

first=first+a

i=0

for element in second:

second[i]=int(element);i=i+1

do=str(first)

dop=str(second)

second.append('.')

j=0

hop = [ element for element in first if element not in second ]

i=0

for element in hop:

hop[i]=int(element);i=i+1

hop=hop+hop1

b = ''

sign=z

for n in range(0, len(hop)):

b += str(hop[n]); b+='.'

resul = sign + '.' + str(len(hop)) + '.' + b

y=numberRL(resul)

result=equal_to_one(y)

return result

3.2 Операція віднімання

def minus(first,second):

'''(str,str)->str

minus numbers

>>>minus('0.4.7.6.5.4.','0.2.7.5.')

'0.2.6.4.'

>>>minus('1.4.7.6.5.4.','0.2.7.5.')

'1.3.8.7.4.'

'''

if first=='0.0.' and second=='0.0.':

result='0.0.'

return result

elif first[0]=='1' and second[0]=='1' and first[2:]==second[2:]:

result='0.0.'

return result

elif first[0]=='0' and second[0]=='0' and first[2:]==second[2:]:

result='0.0.'

return result

elif first=='0.0.':

h=second

elif second=='0.0.':

h=first

else:

h=C(first,second)

if first[0]==second[0] and first==h:

result=summa2(first,second)

return result

elif first[0]=='1' and second[0]=='0' or first[0]=='0' and second[0]=='1':

sum=ConcatRl(first,second)

sum=numberRL(sum)

result=equal_to_one(sum)

return result

elif first[0]==second[0] and second==h:

result=summa1for_min(first,second)

return result

def summa1for_min_for_0g(first, second):

'''(str,str)->str

>>>summa1for_min_for_01('1.4.8.4.5.6.','0.0.')

'1.4.8.6.4.3.'

'''

b=''

n=0

if second=='0.0.':

if first[0]=='0':

for n in range(0, len(first)):

b += str(first[n])

result = b

elif first[0]=='1':

for n in range(0, len(first)):

b += str(first[n])

result = b

3.3 Операція множення

def mnog(first,second):

'''(str,str)->str

umnogenya number

>>>mnog('0.3.14.3.2.','0.3.3.2.1.')

'0.6.17.16.15.7.5.3.'

'''

if first=='0.0.' or second=='0.0.':

result='0.0.'

return result

if first[0]==second[0]:

sign='0'

else:

sign='1'

first=first[first.find('.',2):-1]

second=second[second.find('.',2):-1]

first=first.split('.')

del first[0]

second=second.split('.')

del second[0]

#print(second)

k=int(first[0])

#print(k)

i=0

for element in first:

first[i]=int(element);i=i+1

i=0

for element in second:

second[i]=int(element);i=i+1

#print(second)

i=0

j=0

c=''

k=0

first1=[]

for i in range(0,len(first)):

for j in range(0,len(second)):

c+=str(first[i]+second[j])+'.'

c=c.split('.')

del c[-1]

#print(c)

b=''

for n in range(0, len(c)):

b += str(c[n]); b+='.'

resul = sign + '.' + str(len(c)) + '.' + b

#print(resul)

y=numberRL(resul)

result=equal_to_one(y)

return result

3.4 Операція ділення

def delen(first,second):

'''(str,str)->str

delenye number

>>>delen('0.3.5.3.2.','0.3.3.2.1.')

'0.6.17.16.15.7.5.3.'

'''

if first=='0.0.':

result='0.0.'

return result

if first[0]==second[0] and first[2:]==second[2:]:

result='0.1.0.'

return result

elif first[0]!=second[0] and first[2:]==second[2:]:

result='1.1.0.'

return result

if first[0]=='1' and second[0]=='0' or first[0]=='0' and second[0]=='1':

sign='1'

elif first[0]==second[0]:

sign='0'

jop=[]

i=0

f=first[0]

re=second

do=second[0]

for i in range(0,4):

g=first

first=first[first.find('.',2):-1]

second=second[second.find('.',2):-1]

first=first.split('.')

del first[0]

second=second.split('.')

del second[0]

i=0

for element in first:

first[i]=int(element)

i=i+1

# print(first)

i=0

for element in second:

second[i]=int(element);i=i+1

# print(second)

a=first[0]-second[0]-1

u=a

j=0

c=''

k=0

first1=[]

j=0

for j in range(0,len(second)):

c+=str(second[j]+a)+'.'

j=j+1

#print(c)

c=c.split('.')

del c[-1]

b=''

n=0

for n in range(0, len(c)):

b += str(c[n]); b+='.'

n=n+1

resul =f+ '.' + str(len(c)) + '.' + b

#print(resul,'sec')

#print(g)

d=minus(g,resul)

# print(d,'fir')

ho=str(resul)

#second=ho

ky=str(d)

# print(ky,'ll')

#print(ho)

second=re

first=ky

jop.append(u)

b1=''

for n in range(0, len(jop)):

b1 += str(jop[n]); b1+='.'

resul = sign + '.' + str(len(jop)) + '.' + b1

y=numberRL(resul)

result=equal_to_one(y)

return result

Висновок

У результаті виконання курсового проекту було розроблено програмну модель системи з «безпомилковою арифметикою» на підставі спеціального арифметико-алгоритмічного базису.

Були протестовані програмні коди арифметичних дій у розрядно-логарифмічній формі. На основі створених бібліотек були проведені обрахунки та знаходження оберненої матриці. Шляхом перевірки було доведено, що дані, при обрахунку у розрядно-логарифмічній формі ідентичні простим арифметичним діям.

Отже, розрядно-логарифмічну арифметику можна назвати «безпомилковою арифметикою».

Список використаної літератури

1. Моделювання багато розрядних комп'ютерних систем: Навч. Посібник. - К.: Книжкове вид-во НАУ, 2007.-112с.

2. Конспект лекцій з дисципліни «моделювання систем» .

ДодатОК

def ConcatRl(num1, num2):

'''(str, str) -> str

Return the union of two Rl numbers.

>>> ConcatRl('0.3.5.2.1.', '1.2.7.3.')

'0.5.5.2.1.7.3.'

'''

temp1 = num1[0]

temp2 = num2[0]

#if temp1 == temp2:

sign = temp1

#else:

#sign = '0'

Temp1 = num1[2:num1.find('.',2)]

Temp2 = num2[2:num2.find('.',2)]

Temp = str(int(Temp1) + int(Temp2))

result = sign + '.' + Temp + num1[num1.find('.',2):-1] + num2[num2.find('.',2):]

return result

def numberRL(one):

'''(str)->str

RL number we wanted to sort

>>>numberRL('0.4.3.6.-1.2.')

'0.4.6.3.2.-1.'

>>>numberRL('1.3.4.8.0.')

'1.3.8.4.0.'

'''

one1=one.split('.')

one1=list(one1)

del one1[-1]

for i in range(2,len(one1), 1):#step

for j in range(2,len(one1) - 1):

if int(one1[j])<int(one1[j+1]):

one1[j],one1[j+1]=one1[j+1],one1[j]

empty=''

for j in range(0,len(one1)):

empty+=str(one1[j]);empty+='.'

result=empty

return result

def equal_to_one(num):

'''(str) -> str

Return the Rl number with unique elements.

>>> equal_to_one('0.6.5.4.4.2.0.-5.')

'0.4.6.2.0.-5.'

'''

sign = num[0]

temp = num[num.find('.', 2)+1:]

Temp = temp.split('.')

del Temp[-1]

l = []

for n in range(0, len(Temp)):

l.append(int(Temp[n]))

for k in l:

n = 0; d = []

while n < len(l):

if l[n] in l[n+1:]:

else:

d.append(l[n]); n += 1

l = d; d = []

b = ''

for n in range(0, len(l)):

b += str(l[n]); b+='.'

#b = b[:-1]

result = sign + '.' + str(len(l)) + '.' + b

return result

def C(num1, num2):

'''(str, str) -> str

Return the largest of two Rl numbers or, if two numbers are equal,

return one of them.

>>> C('1.3.4.2.-1.', '0.2.-4.-8.')

'0.2.-4.-8.'

'''

temp1 = num1[num1.find('.', 2) + 1:]

temp2 = num2[num2.find('.', 2) + 1:]

Temp1 = temp1.split('.'); Temp2 = temp2.split('.')

del Temp1[-1]

del Temp2[-1]

if len(Temp1) >= len(Temp2):

for n in range(0, len(Temp2)):

if int(Temp1[n]) > int(Temp2[n]):

result = num1; break

elif int(Temp1[n]) < int(Temp2[n]):

result = num2; break

else:

result = num1

if len(Temp1) < len(Temp2):

for n in range(0, len(Temp1)):

if int(Temp1[n]) > int(Temp2[n]):

result = num1; break

elif int(Temp1[n]) < int(Temp2[n]):

result = num2; break

else:

result = num2

return result

def summa1for_min_for_0(first, second):

''(str,str)->str

>>>summa1for_min_for_0('0.0.','1.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''

b=''

n=0

if first=='0.0.':

if second[0]=='0':

for n in range(0, len(second)):

b += str(second[n])

result = '1' + b[1:]

elif second[0]=='1':

for n in range(0, len(second)):

b += str(second[n])

result = '0' + b[1:]

return result

def summa1for_min_for_0g(first, second):

'''(str,str)->str

>>>summa1for_min_for_01('1.4.8.4.5.6.','0.0.')

'1.4.8.6.4.3.'

'''

b=''

n=0

if second=='0.0.':

if first[0]=='0':

for n in range(0, len(first)):

b += str(first[n])

result = b

elif first[0]=='1':

for n in range(0, len(first)):

b += str(first[n])

result = b

return result

def summa1for_min(first, second):

'''(str,str)->str

for 1 and 0'

if first=='0.0.':

result=summa1for_min_for_0(first,second)

elif second=='0.0.':

result=summa1for_min_for_0g(first,second)

p1=''

p=''

if first[0]==second[0]=='0':

z='1'

else:

z='0'

#z=second[0]

for n in range(0, len(first)):

p += str(first[n])

for n in range(0, len(second)):

p1 += str(second[n])

first=p1

second=p

#print(first)

#print(second)

first=first[first.find('.',2):-1]

second=second[second.find('.',2):-1]

first=first.split('.')

del first[0]

second=second.split('.')

del second[0]

l2 = []

for i in first:

if i not in second:

l2.append(i)

l3 = []

for i in second:

if i not in first:

l3.append(i)

first=l2

second=l3

k=int(first[0])

m=k

hop1=[]

#n=int(second[-1])

#print(first)

#print(second)

if second==[]:

a=[]

else :#change second na first

n=int(second[-1])

a = [i+1 for i in range(n-1,k-1)]

hop1.append(n)

del first[0]

#print(hop1,'k')

i=0

for element in first:

first[i]=int(element);i=i+1

first=first+a

#print(first)

i=0

for element in second:

second[i]=int(element);i=i+1

#print(second)

do=str(first)

#print(do)

dop=str(second)

#print(dop)

#second.append('.')

i=0

j=0

hop = [ element for element in first if element not in second ]

i=0

for element in hop:

hop[i]=int(element);i=i+1

hop=hop+hop1

#print(hop)

b = ''

sign=z

for n in range(0, len(hop)):

b += str(hop[n]); b+='.'

resul = sign + '.' + str(len(hop)) + '.' + b

Размещено на Allbest.ru