HiAsm
HiAsm
Вверх ↑
ФорумыПомощь по пакетуСложение, вычитание элемент Math ← Ctrl1Ctrl →
Этот топик читают: Гость
Ответов: 146
Рейтинг: 1
#1: 2025-08-21 19:09:56 ЛС | профиль | цитата
Подскажите может есть какой-нибудь способ вычислять большие цифры? Компонент Math почему-то не работает с цифрами больше 15 знаков. Например из 30-ти значного нужно вычесть 6-ти значное.
карма: 1

0
Ответов: 8968
Рейтинг: 824
#2: 2025-08-21 20:46:21 ЛС | профиль | цитата
Andrej77rv, в арифметике можно всё, в т. ч. и в HiAsm, но для этого её (арифметику) надо знать. И что же это за задача требующая такой точности (а не таких "больших цифр")

Редактировалось 1 раз(а), последний 2025-08-21 20:48:19
карма: 19

0
Ответов: 146
Рейтинг: 1
#3: 2025-08-21 21:46:03 ЛС | профиль | цитата
Леонид писал(а):
Andrej77rv, в арифметике можно всё, в т. ч. и в HiAsm, но для этого её (арифметику) надо знать. И что же это за задача требующая такой точности (а не таких "больших цифр")

Редактировалось 1 раз(а), последний 2025-08-21 20:48:19

Хотел посмотреть что будет если после SHA-256 отнимать, прибавлять исходные данные и результат хеширования.
карма: 1

0
Ответов: 8968
Рейтинг: 824
#4: 2025-08-23 01:25:28 ЛС | профиль | цитата
Andrej77rv, вот дались вам эти SHA В примере 256-битные числа в Hex представлении.
Пример


Add(MainForm,2953706,56,84)
{
 Width=469
 Height=170
 link(onCreate,10800390:Rendom,[(95,104)(95,90)])
}
Add(Edit,4474551,212,84)
{
 Left=10
 Top=45
 Width=440
 Font=[MS Sans Serif,8,0,0,204]
 Text="2000000000000000000000000000000000000000000000000000000000000000"
 Alignment=1
}
Add(Edit,7105097,170,98)
{
 Left=10
 Top=70
 Width=440
 Font=[MS Sans Serif,8,0,0,204]
 Text="0000000000000000000000000000000000000000000000000000000000000001"
 Alignment=1
}
Add(Edit,13853191,169,168)
{
 Left=10
 Top=95
 Width=440
 Font=[MS Sans Serif,8,0,0,204]
 Alignment=1
}
Add(Button,5937675,56,126)
{
 Left=15
 Top=5
 Caption="New"
 link(onClick,10800390:Start,[(102,132)(102,97)])
}
Add(Button,4863455,56,168)
{
 Left=200
 Top=5
 Width=35
 Font=[MS Sans Serif,12,1,0,1]
 Caption="+"
 link(onClick,10576286:doPlus,[])
}
Add(Button,488327,56,203)
{
 Left=250
 Top=5
 Width=30
 Font=[MS Sans Serif,12,1,0,1]
 Caption="-"
 link(onClick,10576286:doMinus,[(102,209)(102,181)])
}
Add(MultiElementEx,10800390,119,84)
{
 link(LNum,16030688:Text,[])
 link(onBig ,4474551:doText,[])
 link(onSmall,7105097:doText,[(165,97)(165,104)])
}
BEGIN_SDK
  Add(EditMultiEx,3240386,21,21)
  {
   WorkCount=#6:Rendom|5:Start|
   EventCount=#6:onBig |7:onSmall|
   DataCount=#4:LNum|
   Width=328
   Height=221
   VOffset=7
   HOffset=120
   link(Rendom,12025576:doRandomize,[(175,34)(175,62)])
   link(Start,9228995:doEvent1,[])
  }
  Add(For,2083562,70,49)
  {
   End=32
   IncludeEnd=1
   link(onEvent,12025576:doRandom,[])
   link(onStop,15661517:doEvent1,[])
  }
  Add(Random,12025576,182,49)
  {
   Max=255
   link(onRandom,1281201:doConvert,[])
  }
  Add(Convertor,1281201,224,49)
  {
   Mode=6
   link(onResult,181968:doStrCat,[])
  }
  Add(Hub,9228995,35,35)
  {
   link(onEvent1,181968:doClear,[(263,41)(263,62)])
   link(onEvent2,2083562:doFor,[(60,48)(60,55)])
  }
  Add(StrCat,181968,280,49)
  {
   Point(doClear)
   link(Str2,3377666:Var1,[(293,40)(272,40)(272,89)])
  }
  Add(DoData,9914261,280,98)
  {
   link(onEventData,3240386:onBig ,[(319,104)(319,34)])
   link(Data,3377666:Var2,[])
  }
  Add(GetDataEx,3377666,280,84)
  {
   link(Data,181968:Result,[])
  }
  Add(For,11656967,70,147)
  {
   End=32
   IncludeEnd=1
   link(onEvent,1886305:doCompare,[])
   link(onStop,10034507:doData,[(109,160)(109,202)])
  }
  Add(Random,1328279,168,147)
  {
   Max=255
   link(onRandom,6405800:doConvert,[])
  }
  Add(Convertor,6405800,217,147)
  {
   Mode=6
   link(onResult,2584369:doWork2,[])
  }
  Add(Hub,501842,35,133)
  {
   link(onEvent1,5844296:doClear,[(263,139)(263,160)])
   link(onEvent2,11656967:doFor,[(60,146)(60,153)])
  }
  Add(StrCat,5844296,280,147)
  {
   Point(doClear)
   link(Str2,12144989:Var1,[(293,138)(272,138)(272,187)])
  }
  Add(DoData,10034507,280,196)
  {
   link(onEventData,3240386:onSmall,[(326,202)(326,41)])
   link(Data,12144989:Var2,[])
  }
  Add(GetDataEx,12144989,280,182)
  {
   link(Data,5844296:Result,[])
  }
  Add(Hub,15661517,112,56)
  {
   link(onEvent1,9914261:doData,[(157,62)(157,104)])
   link(onEvent2,501842:doEvent1,[(137,69)(137,90)(25,90)(25,139)])
  }
  Add(If_else,1886305,119,147)
  {
   Type=1
   link(onTrue,1328279:doRandom,[])
   link(onFalse,849721:doData,[(158,160)(158,174)])
   link(Op2,3240386:LNum,[(132,96)(147,96)])
  }
  Add(DoData,849721,175,168)
  {
   Data=String(00)
   link(onEventData,2584369:doWork3,[(256,174)])
  }
  Add(HubEx,2584369,252,147)
  {
   link(onEvent,5844296:doStrCat,[])
  }
END_SDK
Add(Edit,16030688,119,28)
{
 Left=95
 Top=5
 Width=40
 Text="3"
 DataType=2
 ClearAfterEnter=1
}
Add(MultiElementEx,10576286,119,168)
{
 link(onRes,13853191:doText,[])
 link(Small,7105097:Text,[(125,138)(176,138)])
 link(Big,4474551:Text,[(132,145)(218,145)])
}
BEGIN_SDK
  Add(EditMultiEx,2886334,21,21)
  {
   WorkCount=#6:doPlus|7:doMinus|0:|
   EventCount=#5:onRes|
   DataCount=#5:Small|3:Big|0:|
   Width=727
   Height=242
   VOffset=50
   HOffset=105
   link(doPlus,10156598:doData,[(32,77)(32,69)])
   link(doMinus,6953895:doData,[(32,84)(32,111)])
  }
  Add(Length,14314511,231,84)
  {
   link(onLength,11118760:doFor,[])
  }
  Add(For,11118760,280,84)
  {
   IncludeEnd=1
   link(onEvent,10719640:doOperation,[])
   link(onStop,749270:doData,[(319,97)(319,230)])
   link(End,6082861:Var2,[])
  }
  Add(Math,10719640,329,84)
  {
   OpType=1
   link(onResult,11933815:doCopy,[])
   link(Op1,6082861:Var3,[(335,75)])
  }
  Add(Memory,11243533,175,84)
  {
   Point(Data)
   link(onData,14314511:doLength,[])
   link(Data,2886334:Big,[(181,54)(139,54)])
  }
  Add(GetDataEx,6082861,287,70)
  {
   Angle=3
   link(Data,14314511:Result,[(272,75)(272,124)(237,124)])
  }
  Add(Memory,11457265,126,84)
  {
   Point(Data)
   link(onData,11243533:doValue,[])
   link(Data,2886334:Small,[])
  }
  Add(Copy,11933815,392,84)
  {
   Count=1
   link(onCopy,6817483:doConvert,[])
   link(Str,11243533:Value,[(398,68)(223,68)(223,124)(181,124)])
   link(Position,1394895:Var1,[(405,75)(384,75)])
  }
  Add(Copy,15299479,392,154)
  {
   Count=1
   link(onCopy,12398631:doConvert,[])
   link(Str,11457265:Value,[(398,131)(132,131)])
   link(Position,1394895:Var3,[(405,124)])
  }
  Add(GetDataEx,1394895,378,119)
  {
   Angle=3
   link(Data,10719640:Result,[(335,124)])
  }
  Add(Convertor,6817483,441,84)
  {
   Mode=5
   Digits=1
   link(onResult,2363448:doValue,[])
  }
  Add(Convertor,12398631,441,154)
  {
   Mode=5
   Digits=1
   link(onResult,11589483:doCalc,[])
  }
  Add(Memory,2363448,497,84)
  {
   Default=Integer(0)
   link(onData,15299479:doCopy,[(543,90)(543,139)(382,139)(382,160)])
  }
  Add(MathParse,14604000,588,196)
  {
   DataCount=1
   MathStr="(%1+16) mod 16"
   ResultType=0
   link(onResult,7018769:doConvert,[])
  }
  Add(Memory,8521680,595,84)
  {
   Default=Integer(0)
  }
  Add(Hub,13966004,546,154)
  {
   link(onEvent1,9031309:doCalc,[])
   link(onEvent2,14604000:doCalc,[(571,167)(571,202)])
  }
  Add(Hub,5693482,91,77)
  {
   link(onEvent1,266219:doEvent1,[(105,62)])
   link(onEvent2,11457265:doValue,[])
  }
  Add(MathParse,9031309,588,154)
  {
   DataCount=1
   MathStr="-1*(0>%1) + (%1>=0)*(%1 div 16) "
   ResultType=0
   link(onResult,8521680:doValue,[(634,160)(634,76)(592,76)(592,90)])
  }
  Add(StrCat,5318111,693,161)
  {
   Point(doClear)
   link(Str2,7405121:Var3,[(706,152)(713,152)(713,208)])
  }
  Add(FastMathParse,11589483,497,154)
  {
   DataCount=3
   MathStr="%1-%2+%3"
   ResultType=0
   Point(doMathStr)
   link(onResult,13966004:doEvent1,[])
   link(X1,2363448:Value,[])
   link(X3,8521680:Value,[(517,145)(601,145)])
  }
  Add(Hub,266219,455,56)
  {
   OutCount=3
   link(onEvent1,5318111:doClear,[(672,62)(672,174)])
   link(onEvent2,8521680:doClear,[(564,69)(564,97)])
   link(onEvent3,11589483:doMathStr,[(480,76)(480,167)])
  }
  Add(GetDataEx,7405121,693,203)
  {
   link(Data,5318111:Result,[])
  }
  Add(Convertor,7018769,630,196)
  {
   Mode=6
   Digits=1
   link(onResult,5318111:doStrCat,[(676,202)(676,167)])
  }
  Add(DoData,749270,693,224)
  {
   link(onEventData,2886334:onRes,[(732,230)(732,77)])
   link(Data,7405121:Var2,[])
  }
  Add(DoData,10156598,42,63)
  {
   Data=String(%1+%2+%3)
   link(onEventData,597443:doWork1,[(81,69)])
  }
  Add(DoData,6953895,42,105)
  {
   Data=String(%1-%2+%3)
   link(onEventData,597443:doWork3,[(81,111)])
  }
  Add(HubEx,597443,77,77)
  {
   link(onEvent,5693482:doEvent1,[])
  }
END_SDK
карма: 19

0
Ответов: 146
Рейтинг: 1
#5: 2025-08-26 07:56:24 ЛС | профиль | цитата
Леонид писал(а):
В примере 256-битные числа в Hex представлении.

Хорошо спасибо. А как сложить каждый бит с битом другого числа по модулю 2 (XOR) ? Ну например 01101000011001010110110001101100 + 01110010011011000110010010000000
Т.е. в такой форме



Это только перебор строки делать?

Редактировалось 7 раз(а), последний 2025-08-26 11:37:09
карма: 1

0
Ответов: 2456
Рейтинг: 695
#6: 2025-08-26 14:10:32 ЛС | профиль | цитата
Andrej77rv, а что такой вариант разве не рабочий:
Add(MainForm,2953706,119,175)
{
 Width=481
 link(onCreate,10699909:doEvent1,[])
}
Add(Edit,15625951,231,140)
{
 Left=35
 Top=80
 Width=335
 Height=25
 Font=[Consolas,12,0,0,204]
 Text="01101000011001010110110001101100"
 Alignment=1
}
Add(Edit,14100131,273,140)
{
 Left=35
 Top=115
 Width=335
 Height=25
 Font=[Consolas,12,0,0,204]
 Text="01110010011011000110010010000000"
 Alignment=1
}
Add(ConvertorEx,3873008,231,189)
{
 Mode=7
 link(onResult,8092647:doConvert,[])
 link(Data,15625951:Text,[])
}
Add(ConvertorEx,8092647,273,189)
{
 Mode=7
 link(Data,14100131:Text,[])
}
Add(Edit,9998415,357,245)
{
 Left=35
 Top=150
 Width=335
 Height=25
 Font=[Consolas,12,0,0,204]
 Text=""
 Alignment=1
}
Add(MathParse,3523066,231,245)
{
 link(onResult,7558206:doConvert,[])
 link(X1,3873008:Var,[])
 link(X2,8092647:Var,[(244,230)(279,230)])
}
Add(Hub,10699909,175,189)
{
 link(onEvent1,3873008:doConvert,[])
 link(onEvent2,3523066:doCalc,[(217,202)(217,251)])
}
Add(ConvertorEx,7558206,308,245)
{
 Mode=8
 link(onResult,9998415:doText,[])
}


Редактировалось 1 раз(а), последний 2025-08-26 14:10:41
карма: 11

0
Ответов: 146
Рейтинг: 1
#7: 2025-08-26 16:16:34 ЛС | профиль | цитата
sla8a писал(а):
а что такой вариант разве не рабочий:

По модулю 2 (XOR) 1+1 должно быть 0 а не 1.
карма: 1

0
Ответов: 527
Рейтинг: 167
#8: 2025-08-26 18:19:18 ЛС | профиль | цитата
Andrej77rv писал(а):
Это только перебор строки делать?

а чем плох перебор ? 

Add(MainForm,2953706,462,301)
{
 Width=316
 Height=150
 link(onCreate,15779215:doEnum,[])
}
Add(Math,275052,644,315)
{
 OpType=6
 link(onResult,16567299:doStrCat,[])
 link(Op1,15779215:Part,[(650,296)(576,296)(576,355)(538,355)])
}
Add(Edit,2292789,525,245)
{
 Left=25
 Top=20
 Width=250
 Font=[MS Sans Serif,8,1,0,1]
 Text="01101000011001010110110001101100"
}
Add(Edit,14247430,595,245)
{
 Left=25
 Top=45
 Width=250
 Font=[MS Sans Serif,8,1,0,1]
 Text="01110010011011000110010010000000"
}
Add(Str_Enum,15779215,525,315)
{
 Delimiter=""
 link(onEnum,8909271:doCopy,[])
 link(onEndEnum,13824030:doText,[(565,328)(565,384)])
 link(String,2292789:Text,[])
}
Add(Copy,8909271,595,315)
{
 Count=1
 link(onCopy,275052:doOperation,[])
 link(Str,14247430:Text,[])
 link(Position,15779215:NumSubStr,[(608,303)(587,303)(587,364)(531,364)])
}
Add(StrCat,16567299,700,315)
{
 link(Str1,14400854:Var1,[(706,303)(688,303)(688,355)])
}
Add(Edit,13824030,700,378)
{
 Left=25
 Top=70
 Width=250
 Font=[MS Sans Serif,8,1,0,1]
 Text="01101000011001010110110001101100"
 link(Str,14400854:Var2,[])
}
Add(GetDataEx,14400854,700,350)
{
 link(Data,16567299:Result,[])
}
карма: 4

0
Ответов: 146
Рейтинг: 1
#9: 2025-08-26 18:47:28 ЛС | профиль | цитата
tig-rrr писал(а):
а чем плох перебор ?

Не знаю может скорость вычисления замедляется. Таких операций нужно очень много сделать если для схемы SHA-256.
карма: 1

0
Ответов: 8968
Рейтинг: 824
#10: 2025-08-26 19:06:22 ЛС | профиль | цитата
Andrej77rv, такие операции надо делать в IC без преобразования в строки.
Следует отметить, что обратное преобразование HESH суммы в исходный файл невозможно, файлов с такой суммой бесконечное множество
карма: 19

0
Ответов: 146
Рейтинг: 1
#11: 2025-08-26 19:14:04 ЛС | профиль | цитата
Леонид писал(а):
Следует отметить, что обратное преобразование HESH суммы в исходный файл невозможно, файлов с такой суммой бесконечное множество

Так это понятно. Просто интересно как это всё устроено. На этом алгоритме очень много что работает.

Редактировалось 3 раз(а), последний 2025-08-26 19:20:06
карма: 1

0
Ответов: 146
Рейтинг: 1
#12: 2025-08-27 13:49:22 ЛС | профиль | цитата
Подскажите еще как сделать побитовый сдвиг вправо на 6 на компоненте MathParse ? Например числа 01101000011001010110110001101100. Последние 6 бит должны перейти в начало.
карма: 1

0
Ответов: 8968
Рейтинг: 824
#13: 2025-08-27 22:41:14 ЛС | профиль | цитата
Andrej77rv писал(а):
на компоненте MathParse
Не работает MathParse с битами! Раздел "Строки" изучайте.
Строки


Add(MainForm,2953706,70,161)
{
 Height=146
}
Add(Label,16010429,70,112)
{
 Left=10
 Top=35
 Caption="Переместить"
}
Add(Edit,15534779,238,84)
{
 Left=85
 Top=35
 Width=40
 Text="6"
 DataType=2
}
Add(Label,2263545,119,112)
{
 Left=130
 Top=35
 Caption="символов из окончания в начало"
}
Add(Edit,16030860,182,84)
{
 Left=5
 Top=5
 Width=370
 Text="01101000011001010110110001101100"
}
Add(Edit,12486798,532,161)
{
 Left=5
 Top=65
 Width=370
}
Add(Button,5647210,133,161)
{
 Left=310
 Top=35
 Caption=">>>"
 link(onClick,5178570:doLength,[])
}
Add(Length,5178570,182,161)
{
 link(onLength,149539:doOperation,[])
 link(Str,11394546:Var2,[])
}
Add(Copy,977682,336,161)
{
 link(onCopy,1774208:doValue,[])
 link(Str,6492981:Var2,[])
 link(Position,10343967:Result,[(349,152)(328,152)(328,201)(286,201)])
 link(Count,3793510:Var3,[(356,138)])
}
Add(GetDataEx,11394546,182,140)
{
 link(Data,16030860:Text,[])
}
Add(GetDataEx,3793510,238,133)
{
 link(Data,15534779:Text,[])
}
Add(Memory,1774208,378,161)
{
 link(onData,13911957:doCopy,[])
}
Add(GetDataEx,6492981,336,140)
{
 Angle=3
 link(Data,11394546:Var3,[])
}
Add(Copy,13911957,427,161)
{
 Position=1
 link(onCopy,3088606:doStrCat,[])
 link(Str,6492981:Var3,[(433,145)])
 link(Count,149539:Result,[(447,152)(419,152)(419,208)(237,208)])
}
Add(Math,10343967,280,161)
{
 Op1=1
 ResultType=0
 link(onResult,977682:doCopy,[])
}
Add(Math,149539,231,161)
{
 OpType=1
 link(onResult,10343967:doOperation,[])
 link(Op2,3793510:Var2,[])
}
Add(StrCat,3088606,476,161)
{
 link(onStrCat,12486798:doText,[])
 link(Str1,1774208:Value,[(482,152)(468,152)(468,201)(384,201)])
}
карма: 19

0
Ответов: 146
Рейтинг: 1
#14: 2025-08-28 07:16:00 ЛС | профиль | цитата
Леонид писал(а):
Andrej77rv писал(а):
на компоненте MathParse
Не работает MathParse с битами! Раздел "Строки" изучайте.
Строки

Просто в справке к нему указаны побитовые сдвиги. Я и подумал



Редактировалось 1 раз(а), последний 2025-08-28 07:40:36
карма: 1

0
Ответов: 8968
Рейтинг: 824
#15: 2025-08-28 20:35:21 ЛС | профиль | цитата
Andrej77rv писал(а):
Просто в справке
так долго-ли опробовать и выложить результат
карма: 19

0
15
ФорумыПомощь по пакетуСложение, вычитание элемент Math ← Ctrl1Ctrl →
Сообщение
...
Прикрепленные файлы
(файлы не залиты)
HiAsm Studio 2003 - 2025
Пользовательское соглашение | support@hiasm.com
Яндекс.Метрика