Для записи на дискету нужно посчитать контрольную сумму в 1С по вот такому алгоритму :
int CRCTAB_16[]={
    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 значений
DWORD calcCRC16(DWORD iPrevSumm, BYTE *btArr, UINT iLen)
{
  for (int i=0;i<iLen;i++)
    iPrevSumm=(CRCTAB_16[(iPrevSumm>>8)&0xFF] ^ iPrevSumm<<8 ^ btArr[i])&0xFFFF;
  return iPrevSumm;
}
На вход подаем btArr столько раз, сколько строк iLen - длина входной строки
Сделал в 1С через работу со строками - ужасные тормоза.
Самому писать ВК - ломает, давно уже на сях не лепил.
Мож есть уже готовая ? Киньте ссылкой плз.
или алгоритм для 1С - мож кто более быстрый придумает.

Причем тут строки, все операции делаются с числами и работают вполне быстро. Раскладывай коды символов на степени дойки и производи с ними нужные операции.

Помоему 1С не позволяет делать ПОБИТНЫЕ ОПЕРАЦИИ "Логическое ИЛИ" и т.д.
Мож я не прав ? Тогда строчку кода плз.

+(2) Ну получу я код буквы "А" - 145,
как мне его побитно ксор сделать с 30467 ?

(2) Код писать лень.
Простейший алгоритм, нам нужна функция для
получения логического ИЛИ двух чисел
Раскладываешь их по степеням двойки в две строки
10010001
00101101
потом проходишь по каждому символу, получаешь
10111101
и преобразовываешь эту строку в число, умножая каждую единицу на нужную степень двойки.

+(0) ===> Сделал в 1С через работу со строками - ужасные тормоза.
Я это и имел ввиду !

(5) Покажи код.

(0) подскажи iPrevSumm>>8 и iPrevSumm<<8 на сях что? счас свояю

И скажи сколько символов в файле.
(конечно через длл га С++ будет быстрее, но тут роде бы тоже большим тормозам взяться неоткуда)

(0) необязательно на 1Сэ, ест ВБС и наконец офис(можно хоть свой ГУИ своять)

собственно вот описанное в (4)
http://1c.realnet.ru/cgi-bin/forum.cgi?ask=12755

На вход алгоритма дается не менее 100 строк с длиной от 1 до не менее 100 символов.
У меня получилось каждый символ через 2 цикла пропускать на каждой логической операции - которых 3, Жуть !
Еще сдвиг - тоже символьные опреации Лев() - Прав().
Ща код вывалю.
(7)iPrevSumm>>8 - Это логический сдвиг на 8 битов вправо.

еще вопрос с возвратом на первый бит (и сразу или через бит четности или как еще) ?

(10) IAm спасибо за ссылку - только не могу оттуда достать файлы Ж:0~
А вообщем там помоему еще хуже ( в смысле медленнее ), чем у меня сделано.
Вот творение моего гения :) - оптимизированное до невозможности ! ;)
ЗначенияБитов[ 1 ] = 1 ;
ЗначенияБитов[ 2 ] = 2 ;
ЗначенияБитов[ 3 ] = 4 ;
ЗначенияБитов[ 4 ] = 8 ;
и т.д. до 32
// Сдвиг
// Направление 1 - вправо >>
// -1 - влево <<
// оптимизируем поднужды !!!!!!!!!!!!!!!!!!!!!
//=============================================================
Функция Сдвиг( Код, Размер, Направление ) Экспорт
  Перем кс ;
  Если Направление > 0 Тогда
    кс = Лев( Код, СтрДлина( Код ) - Размер ) ;
    Для ф = 1 По Размер Цикл
      кс = "0" + кс ;
    КонецЦикла ;
  Иначе
    кс = Прав( Код, СтрДлина( Код ) - Размер ) ;
    Для ф = 1 По Размер Цикл
      кс = кс + "0" ;
    КонецЦикла ;
  КонецЕсли ;
  Возврат кс ;
КонецФункции
// Ксор
// Длина кодов должна быть одинакова !!!
//============================================================
Функция Ксор( Код1, Код2 ) Экспорт
  Перем Длина ;
  Перем кс ;
  Длина = СтрДлина( Код1 ) ;
  кс = "" ;
  
  Для ф = 1 По Длина Цикл
    т1 = Сред( Код1, ф, 1 ) ;
    т2 = Сред( Код2, ф, 1 ) ;
    кс = кс + ?( т1 = т2, "0", "1" )
  КонецЦикла ;
  Возврат кс ;
КонецФункции
//
// Расчет контрольной суммы
// С - входная строка, по которой считать кс
//=================================================================
Функция РасчетКС( ПредСум, С ) Экспорт
    Перем Длина ;
    Перем ч1 ;
    Перем ч2 ;
    Перем ч3 ;
  
// Сообщить(С) ;
    Длина = СтрДлина( С ) ;
    Для ф = 1 По Длина Цикл
  ч1 = Лев( ПредСум, 8 ) ;
        ч2 = Прав( ПредСум, 8 ) +
             БинарныеЗначения[ КодСимв(Сред( С, ф, 1 )) + 1 ] ;
  ПредСум = Ксор( CRCTAB_16[ Десятичное( ч1, 8 ) + 1 ], ч2 ) ;
    КонецЦикла ;
    Возврат ПредСум ;
КонецФункции

+(13) Не захватил немного
// Перевод бинарного представления в десятичное
// Размер - длина бинарного слова
//===================================================================
Функция Десятичное( Код, Размер = 16 ) Экспорт
  Перем кс ;
  Перем Р ;
  кс = 0 ;
  Р = Размер + 1 ;
  Для ф = 1 По Размер Цикл
    Если Сред( Код, ф, 1 ) = "1" Тогда
      кс = кс + ЗначенияБитов[ Р - ф ] ;
    КонецЕсли ;
  КонецЦикла ;
  Возврат кс ;
КонецФункции

замени
     Для ф = 1 По Размер Цикл
      кс = "0" + кс ;
    КонецЦикла ;
нули="000000000000000000000000000000000000000000"
длинакода=стрдлина(код)
на прав(нули+кс,длинакода) и определяй длинукода один раз в начале функции

(15) Я так и знал, что можно еще что-то придумать !!!
Спасибо smaharbA !!! Одним циклом меньше.

+(13) БинарныеЗначения[] - это таблица строк, представляющих числа
для быстрого перевода кода символа, заполняется 1 раз при старте 1С :
БинарныеЗначения[ 15 ] = "00001111"
БинарныеЗначения[ 16 ] = "00010000" и т.д. до 256

(17) слушай у тебя нет "арифметического" алгоритма сдвига влево
вправо просто CS=a / (2 ^ n) (правда проблеммы с округлением, но решаемо)

+(18) ^ - здесь это степень

Таак !!! Сейчас взглянул на свой алгоритм еще разок,
я ж отказался от процедуры сдвига !!! Ж:)
Вместо сдвигов у меня в РасчетКС() :
    ч1 = Лев( ПредСум, 8 ) ;
    ч2 = Прав( ПредСум, 8 ) + и т.д.
Отказался от универсальности, Принял длину ПредСум = 16.

(19) Потом число все-равно переводить в строку,
а переводить на лету все-ж таки медленнее, чем выбрать значение из массива.
К слову вот процедурка, которой я заполняю БинарныеЗначения[], повторюсь, она работает всего один раз при старте 1С :
// Возвращает бинарное представление символа
// Код - Символ
// Размер - Длина бинарного кода
//====================================================
Функция Бинарное( Код, Размер = 16 ) Экспорт
  Перем Токен ;
  Перем Токен2 ;
  Перем кс ;
  Перем Бит ;
  
  Токен = Число( Код ) ;
  
  кс = "" ;
  Пока Токен > 0 Цикл
    Токен2 = Цел( Токен / 2 ) ;
    Бит = Токен - Токен2 * 2 ;
    кс = "" + Бит + кс ;
    Токен = Токен2 ;
  КонецЦикла ;
  
  Л = СтрДлина( кс ) ;
  Пока Л < Размер Цикл
    кс = "0" + кс ;
    Л = Л + 1 ;
  КонецЦикла ;
  Возврат кс ;
КонецФункции

+(21) В смысле один раз для каждого значения массива.
Сначала хотел универсальности, но жизнь в лице 1сv7 сказала, что не будет мне счастья на её платформе с такими замашками.

вобщем так тупенько(мож где ошибся)
Dim CRCTAB_16(255)
Sub main()
CRCTAB_16(0) = 0
For i = 1 To 255
CRCTAB_16(i) = CRCTAB_16(i - 1) + &H1021
Next
End Sub
' 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 &#231;&#237;&#224;&#247;&#229;&#237;&#232;&#233;
Function sdvig(a, n, leftorright)
astr = ""
res = 0
If a > 0 Then
For i = Int(Log(a) / Log(2)) To 0 Step -1
If res + 2 ^ i > a Then
astr = astr + "0"
Else
astr = astr + "1"
res = res + 2 ^ i
End If
Next
Else
astr = "0"
End If
astr = "000000000000000000000000000000000000000000000000000" & astr
alen = Len(astr)
If leftorright Then
cs = Right(astr, alen - n)
cs = Right("000000000000000000000000000000000000000000000000000" & cs, Len(astr))
Else
cs = Left(astr, alen - n)
cs = Left(cs & "000000000000000000000000000000000000000000000000000", Len(astr))
End If
res = 0
cslen = Len(cs)
For i = 1 To cslen
If Mid(cs, cslen - i + 1, 1) = "1" Then
res = res + 2 ^ (i - 1)
End If
Next
sdvig = CLng(res)
End Function
Function calcCRC16(iPrevSumm, btArrStr)
  For i = 1 To Len(btArrStr)
    iPrevSumm = (CRCTAB_16(sdvig(iPrevSumm, 8, True) And &HFF) Xor sdvig(iPrevSumm, 8, False) Xor Asc(Mid(btArrStr, i, 1))) And &HFFFF
  Next
calcCRC16 = iPrevSumm
End Function
Wscript.echo calcCRC16(0, "kl;sfj ;lskdjf;dfj1")
(вроде все верно)

Немного пичасал (для универсальности) теперь прикрутить к 1Сэ проблем несоставит, можно и под ней запускать через содатьобъект и т.д.
....
Dim CRCTAB_16(255)
...
Sub main()
  CRCTAB_16(0) = 0
  For i = 1 To 255
    CRCTAB_16(i) = CRCTAB_16(i - 1) + &H1021
  Next
End Sub
' 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 значений
Function sdvig(a, n, leftorright)
  astr=Dec2BinStr(a)
  astr = "000000000000000000000000000000000000000000000000000" & astr
  alen = Len(astr)
  If leftorright Then
    cs = Right(astr, alen - n)
    cs = Right("000000000000000000000000000000000000000000000000000" & cs, Len(astr))
  Else
    cs = Left(astr, alen - n)
    cs = Left(cs & "000000000000000000000000000000000000000000000000000", Len(astr))
  End If
  res=BinStr2Dec(cs)
  sdvig = CLng(res)
End Function
...
Function calcCRC16(iPrevSumm, btArrStr)
  For i = 1 To Len(btArrStr)
    iPrevSumm = (CRCTAB_16(sdvig(iPrevSumm, 8, True) And &HFF) Xor sdvig(iPrevSumm, 8, False) Xor Asc(Mid(btArrStr, i, 1))) And &HFFFF
  Next
  calcCRC16 = iPrevSumm
End Function
...
function Dec2BinStr(a)
  astr = ""
  res = 0
  If a > 0 Then
    For i = Int(Log(a) / Log(2)) To 0 Step -1
      If res + 2 ^ i > a Then
        astr = astr + "0"
      Else
        astr = astr + "1"
        res = res + 2 ^ i
      End If
    Next
  Else
    astr = "0"
  End If
  Dec2BinStr=astr
end function
...
function BinStr2Dec(a)
  res = 0
  alen = Len(a)
  For i = 1 To alen
    If Mid(a, alen - i + 1, 1) = "1" Then
      res = res + 2 ^ (i - 1)
    End If
  Next
  BinStr2Dec=res
end function
...
main
WScript.echo hex(calcCRC16(0, "kl;sfj ;lskdjf;dfj1"))

нестыковочка в (11) :))
"длиной от 1 до не менее 100 символов" - т.е. длина в диапазоне от 2 до 99 в условие не попадает... :))

// Никаких строк ненадо
Перем МассивКодов[256];
Функция ЛогическоеСложение(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  Пока (Число1>0) и (Число2>0) Цикл
    Результат = Бит * (((Число1 % 2) + (Число2 % 2)) % 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
  КонецЦикла;
  Возврат Результат;
КонецФункции // ЛогическоеСложение
Функция ЛогическоеИ(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  Пока (Число1>0) и (Число2>0) Цикл
    Результат = Бит * Цел(((Число1 % 2) + (Число2 % 2)) / 2) + Результат;
    Бит = Бит * 2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
  КонецЦикла;
  Возврат Результат;
КонецФункции // ЛогическоеИ
Функция СдвигНа8Вправо(Знач Число1)
  Возврат Число1 * 256;
КонецФункции // СдвигНа8Вправо
Функция СдвигНа8Влево(Знач Число1)
  Возврат Цел(Число1 / 256);
КонецФункции // СдвигНа8Влево
Функция Контролька(Знач ПредСумма, тСтрока)
  Длина=СтрДлина(тСтрока);
  Для Номер=1 По Длина Цикл
    КодСимвола=КодСимв(Сред(тСтрока, Номер, 1));
    Ч1=МассивКодов[ЛогическоеИ(СдвигНа8Влево(ПредСумма), 255)];
    Ч1=ЛогическоеСложение(Ч1, СдвигНа8Вправо(ПредСумма));
    Ч1=ЛогическоеСложение(Ч1, КодСимвола));
    ПредСумма=ЛогическоеИ(Ч1,65535);
  КонецЦикла;
  Возврат ПредСумма;
КонецФункции // Контролька

+26.
Блин, сдвиг влево/вправо перепутал, чуть подправить надо.

// Вот еще упростил.
Перем МассивКодов[256];
Функция ЛогическоеСложение(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  Пока (Число1>0) и (Число2>0) Цикл
    Результат = Бит * (((Число1 % 2) + (Число2 % 2)) % 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
  КонецЦикла;
  Возврат Результат;
КонецФункции // ЛогическоеСложение
Функция Контролька(Знач ПредСумма, тСтрока)
  Длина=СтрДлина(тСтрока);
  Для Номер=1 По Длина Цикл
    КодСимвола=КодСимв(Сред(тСтрока, Номер, 1));
    Ч1=МассивКодов[(Цел(ПредСумма)/256) % 256)];
    Ч1=ЛогическоеСложение(Ч1, ПредСумма * 256);
    ПредСумма=ЛогическоеСложение(Ч1, КодСимвола) % 65536;
  КонецЦикла;
  Возврат ПредСумма;
КонецФункции // Контролька

(26) ты это чего, если так сдвиг понимать то все просто, но сдвиг то с "уходом" последнего/первого бита, вот тут и проблемма...

да конечно мне тож надо подправить (сделал минимальную длинну кода 2 байта)
Function sdvig(a, n, leftorright)
  astr=Dec2BinStr(a)
  alen = Len(astr)
  if alen<16 then
  astr = right("000000000000000000000000000000000000000000000000000" & astr,n*2)
  alen=16
  end if
  If leftorright Then
    cs = Right(astr, alen - n)
    cs = Right("000000000000000000000000000000000000000000000000000" & cs, Len(astr))
  Else
    cs = Left(astr, alen - n)
    cs = Left(cs & "000000000000000000000000000000000000000000000000000", Len(astr))
  End If
  res=BinStr2Dec(cs)
  sdvig = CLng(res)
End Function

// Вот еще чуть упростил
Перем МассивКодов[256];
Функция ЛогическоеСложение(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  ~повтор:
    Результат = Бит * (((Число1 % 2) + (Число2 % 2)) % 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
    Если Число1 = 0 Тогда
      Возврат Результат + Число2 * Бит;
    ИначеЕсли Число2 = 0 Тогда
      Возврат Результат + Число1 * Бит;
    КонецЕсли;
  Перейти ~повтор;
КонецФункции // ЛогическоеСложение
Функция Контролька(Знач ПредСумма, тСтрока)
  Длина=СтрДлина(тСтрока);
  Для Номер=1 По Длина Цикл
    КодСимвола=КодСимв(Сред(тСтрока, Номер, 1));
    Ч1=МассивКодов[(Цел(ПредСумма)/256) % 256)];
    Ч1=ЛогическоеСложение(Ч1, ПредСумма * 256);
    ПредСумма=ЛогическоеСложение(Ч1, КодСимвола) % 65536;
  КонецЦикла;
  Возврат ПредСумма;
КонецФункции // Контролька

(29) При сдвиге вправо уход первого бита отсекается Цел()
При сдвиге влево надо тогда задавать еще разрядность числа,
например при 16 разрядах надо тогда сделать так:
Число * 256 % 65536;
те отсекать путем остатка от деления на 2^(разрядность числа),
Но конкретно в данном случае уход за 16 разряд несущественен,
так как все равно к первому сдвигу применяется &0xFF (отброс битов старше 8), и потом &0xFFFF (отброс битов после 16)

Написал бы dll, как OLE сервер, и дело с концом

(32) точно...

// Вот, теперь все поправил, нумерация массива в 1С то с 1!!!
Перем МассивКодов[256];
Функция ЛогическоеСложение(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  ~повтор:
    Результат = Бит * (((Число1 % 2) + (Число2 % 2)) % 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
    Если Число1 = 0 Тогда
      Возврат Результат + Число2 * Бит;
    ИначеЕсли Число2 = 0 Тогда
      Возврат Результат + Число1 * Бит;
    КонецЕсли;
  Перейти ~повтор;
КонецФункции // ЛогическоеСложение
Функция Контролька(Знач ПредСумма, тСтрока)
  Длина=СтрДлина(тСтрока);
  Для Номер=1 По Длина Цикл
    КодСимвола=КодСимв(Сред(тСтрока, Номер, 1));
    Ч1=МассивКодов[1+((Цел(ПредСумма)/256) % 256))];
    Ч1=ЛогическоеСложение(Ч1, ПредСумма * 256);
    ПредСумма=ЛогическоеСложение(Ч1, КодСимвола) % 65536;
  КонецЦикла;
  Возврат ПредСумма;
КонецФункции // Контролька
....
Если надо, кину код для ^, |, &, ~, <<, >>

(35) тока подправь % 255 и % 65535
это FF и FFFF соответственно

(36)
Не, "& 0xFF" в С++ == "% 256" в 1С, тк остаток от деления на 256 как раз
от 0 до 255.

( 25 ) Очепятался - длина или 1, или >= 100
2 All - Спасибо за помощь, сегодня попробую все,
вечером скажу чья метода быстрее.
2 orefkov : Если Вы автор 1С++,
подскажите что будет быстрее работать в цикле ?
 а) код на 1С
 б) вызов Wscript 10000 раз
 в) вызов функции DLL ( OLE ) 10000 раз
 г) Что-нибудь еще?
Я слышал, вызов функций через OLE в 1С не самая оптимальная разработка.

Хоть и не автор 1С++, но быстрее всего будет работать длл на С++ со встроенными побитовыми операциями

Я не автор 1С++, хотя часть моего кода там есть.
А по поводу быстродействия - хз, смотря что за код
в каждом конкретном случае. Тестировать надо.

2 orefkov :
=============> Если надо, кину код для ^, |, &, ~, <<, >>
Надо :) для XOR ! - для скорости теста.

 А что этот процент (%) значит? Остаток от деления?

+(39) и выполненная по технологии Rainbow.
(41) XOR - это и есть ЛогическоеСложение (код уже был)
...
// ^
Функция БитовыйXOR(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  ~повтор:
    Результат = Бит * (((Число1 % 2) + (Число2 % 2)) % 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
    Если Число1 = 0 Тогда
      Возврат Результат + Число2 * Бит;
    ИначеЕсли Число2 = 0 Тогда
      Возврат Результат + Число1 * Бит;
    КонецЕсли;
  Перейти ~повтор;
КонецФункции // БитовыйXOR
// &
Функция БитовыйAnd(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  ~повтор:
    Результат = Бит * Цел(((Число1 % 2) + (Число2 % 2)) / 2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
    Если (Число1=0) или (Число2=0) Тогда
      Возврат Результат;
    КонецЕсли;
  Перейти ~повтор;
КонецФункции // БитовыйAnd
// |
Функция БитовыйOR(Знач Число1, Знач Число2)
  Бит=1;
  Результат=0;
  ~повтор:
    Результат = Бит * Цел((((Число1 % 2) + (Число2 % 2) + 1)/2) + Результат;
    Бит = Бит*2;
    Число1 = Цел(Число1/2);
    Число2 = Цел(Число2/2);
    Если Число1 = 0 Тогда
      Возврат Результат + Число2 * Бит;
    ИначеЕсли Число2 = 0 Тогда
      Возврат Результат + Число1 * Бит;
    КонецЕсли;
  Перейти ~повтор;
КонецФункции // БитовыйOR
//~
Функция БитовыйNOT(Знач Число1, Знач КолРазрядов)
  Бит=1;
  Результат=0;
  Для Номер=1 По КолРазрядов Цикл
    Результат=Бит * (1-(Число1 % 2)) + Результат;
    Результат = Цел(Результат / 2);
    Бит = Бит * 2;
  КонецЦикла;
КонецФункции // БитовыйNOT
// <<
Функция БитовыйСдвигВлево(Знач Число1, Знач Число2, Знач КолРазрядов=32)
  Разряд=1;
  Для Номер=1 По КолРазрядов Цикл
    Разряд = Разряд * 2;
  КонецЦикла;
  Для Номер=1 По Число2 Цикл
    Число1 = Число1 * 2;
  КонецЦикла;
  Возврат Число1 % Разряд;
КонецФункции // БитовыйСдвигВлево
// >>
Функция БитовыйСдвигВправо(Знач Число1, Знач Число2)
  Пока (Число1>0) и (Число2>0) Цикл
    Число1 = Цел(Число1/2);
    Число2 = Число2 - 1;
  КонецЦикла;
  Возврат Число1;
КонецФункции // БитовыйСдвигВправо

//~ правильный
Функция БитовыйNOT(Знач Число1, Знач КолРазрядов)
  Бит=1;
  Результат=0;
  Для Номер=1 По КолРазрядов Цикл
    Результат=Бит * (1-(Число1 % 2)) + Результат;
    Число1 = Цел(Число1 / 2);
    Бит = Бит * 2;
  КонецЦикла;
КонецФункции // БитовыйNOT

(43) похоже алгоритм (0) будет верно работать только с побитовыми (относится только к ксор) операциями, так что кучу циклов в КСОР необойти...

Щас прогнал тестик, 100 раз по строке 100 символов,
на Cel-2.4G примерно 4 сек.

(46) на ВБС тот же результат для файла 60 кб строк 1373 но на цел667, да там еще и файл читает и результат в файл записывает по строке на контр.сумму.

вот мой вариант (с учетом обнаруженного у orefkov, спасибо) но на ВБС
...
Dim CRCTAB_16(255)
Const ForReading = 1
Const ForWriting = 2
Set fso = CreateObject("Scripting.FileSystemObject")
'...
Sub main()
  CRCTAB_16(0) = 0
  For i = 1 To 255
    CRCTAB_16(i) = CRCTAB_16(i - 1) + &H1021
  Next
End Sub
' 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 значений
'...
Function calcCRC16(iPrevSumm, btArrStr)
  For i = 1 To Len(btArrStr)
    iPrevSumm = (CRCTAB_16(sdvigNew(iPrevSumm, 8, True) And 255) Xor sdvigNew(iPrevSumm, 8, False) Xor Asc(Mid(btArrStr, i, 1))) And 65535
  Next
  calcCRC16 = iPrevSumm
End Function
'...
Function sdvigNew(a, n, leftorright)
  if a=0 then
    sdvigNew = 0
    exit function
  else
    at=2^(Int(Log(a) / Log(2)))+1
  end if
  if at<2^15+1 then
    at=2^15+1
  end if
  if lefttoright then
    res=a / (2 ^ n)
  else
    res=a * (2 ^ n) mod at
  end if
sdvigNew = res
end function
'...
main
If WScript.Arguments.Count > 0 Then
  Set f = fso.OpenTextFile(Wscript.arguments.item(0), ForReading, True)
  Set crc = fso.OpenTextFile(Wscript.arguments.item(0)&".crc", ForWriting, True)
  crcSTR=""
  Do While Not f.AtEndOfStream
    crcSTR="" & hex(calcCRC16(0, f.ReadLine())) & vbCrLf & crcSTR
  loop
  crc.write crcSTR
  crc.close
  f.close
else
  WScript.echo hex(calcCRC16(0, "kl;sfj ;lskdjf;dfj1"))
end if
(прикрутить к 1Сэ труда несоставит, но у orefkov лучче по той причине что написано все на 1Сэ)

небольшая поправка вместо 2^15+1 надо 2^16-1

Прикольная реализация исключающего ИЛИ. Сам придумал?
Результат = Бит * (((Число1 Mod 2) + (Число2 Mod 2)) Mod 2) + Результат

(50) В некоторых источниках "Исключающее ИЛИ" называется
"Сложение по модулю 2"

(35) 2 orefkov :
   Прогнал Ваш алгоритм - ошибка.
   Здесь :
========> 1+((Цел(ПредСумма)/256) % 256))
   Если ПредСумма = 12504, должно быть 49 !!! Это 5-й символ, первые 4 на ура, я уж и обрадовался.
2 smaharbA : я тоже подумал, если доделаем алгоритм оrefkov, тогда можно избежать геморроя с wScript, машины везде разные, 98, XP, 2000 :) Но все-равно спасибо за поддержку.

(52) Так 49 и получается.

+53 вот блин
1+((Цел(ПредСумма/256) % 256)

(52) можешь закинуть в ворд, и по оле открывать вернет в 1С строку, файл можно и не показывать... (ворд счас практически у всех есть), делаем проверку на скрипт - запускаем скрипт, нет - запускаем через ворд...

(51) Угу, у них математиков, а у нас смертных это булева операция :) Если приёмник или (Или) источник истина, при условии что они неравны (исключение), то и результат тоже истина.

Ниасил ветку.
Сделай массивы. Для NOT(на 256 элементов),XOR,OR(на 256*256 элементов).
Остальное из них сварганишь.
И очень быстро будет считать.
Хранить массивы можешь в файле.

Что ни говори, как не извращайся, а процессор выполняет булевые операции над регистрами за 1 такт.

(58) если данные в 1 - 2 байта, счас и 4 обрабатывает (но там не все так просто), но и при этом надо комманду загрузить + данные, если длинна данных до 3 байт то в некоторых операциях и за такт

(59) не понял - это к чему?
Даже ММХ работает с восьмью. Не говоря о том, что сейчас.
А процессор - 32битный, и обрабатавает соответственно 4 байта за операцию.
Насчет тактов - там есно всё не так просто.
А вот с двумя как раз всё плохо. У Пня четвертого на 16 разрядных операциях затыкается конвеер - легко проверить даже в тех-же делфях.
Скорость обработки 8битных и 32битных примерно одинаковая (в расчете на бит - 32 битные в четыре раза быстрее, ММХ еще почти в два раза быстрее)

(59) А почему до 3-х? За 1 такт выполняются почти все операции с регистрами в качестве операндов.
 Это я вообще всё к чему говорю, нашёл в инете перекомпилированную в DLL ollydbg и через VB-шную ActiveX.DLL сделал к ней интерфейс.
Саму библиотеку выложил у себя на сайте:
http://basicproduction.nm.ru/TOOLS/olly_dll.zip
 Кто хочет действительно быстро что то посчитать вполне может ей воспользоваться. Я проверял - всё работает.

А 10 байт MMX не берёт? Ведь в сопроцессор можно и BCD грузить.

(60) Может из за того что 16-разрядные операции длиннее за счёт префикса размера операнда?

(60) (61) а куда вы команду денете из тех 4 байт? ребята, новые знаю слабовато но принцыпы неизменились начиная с 4040/8080... (тока ненадо про всякие конвееры и такуюже лабуду АЛУ как работало на 4 битах так и работает + команду надо отправить, если все отправлять за такт то и выходит 8 бит команда 24 бита данные, но это утрированно)

Действительно на старых процессорах эти операции выполнялись за несколько тактов, но начиная с 486, за один.

http://www.5ka.ru/95/27252/1.html
.
Элементарные операции целочисленного АЛУ.
Логическое сложение, ИЛИ|V, |, or
.
Именно эти операции выполняются за один такт микропроцессора, и
имеют наибольшую скорость выполнения.

(65) не читайте публицистику, там все врут...
подумай как сделать операцию с двумя словами (пусть уже каждое и в регистре) нужно отправить команду(такт) и выполнить действие(такт)...
и незабудьте что в регистрах данные сами по себе не рождаются шина то 32 тоесть чтоб запихать из озу в каждый регистр по слову надо 2 такта - итого 4 такта, конечно сама логика выполняется за такт(невсегда, тут все упрощенно описал) но данные надо передать

(67) То, что я привел цифры - тестировалось мной в Делфях.
Делфи тоже врут? Код ассеблерный на таких операциях у них идеальный.

+(67) и еще, ребята на 8080 сваял не один контроллер, даже нашол ошибку в выполнении аппаратного прерывания в нашем варианте 580ик80... не изменилась даже система команд(почти)... и данные хоть 8 битные хоть 32 битные идут все по темже 8 и 32 "проводкам" соответственно (если не принимать в счет последовательную/параллельнопоследовательную передачу)

(68) В смысле код идеальный? Ты опкоды имеешь ввиду?

(67) Во первых у пенька вроде уже 64-битная шина данных, а во вторых зачем работать со словами? Лучше уж с байтами или двойными словами. Слова скорее нужны для совместимости со старым, 16-разрядным режимом процессора.

(70) Я имею в виду ассемблерный код, поле компиляции, который, например, можно увидеть при отладке.

(71) ну я имел в виду двойные слова

Вообще кому нибудь будет интересен рантаймовый ассемблер? Можно мнемоники на русский попереводить, щоб вообще как у 1С было :)

2 All : Все это очень интересно, НО !!!
Мой алгоритм эмулирования бинарных операций через строки (13)
создает файл размером 82 кб за 8 сек. (восемь)
Алгоритм г-на orefkov (35) при формировании того-же файла
работал 52 сек. (Пятьдесят две) :(О) !!!
Я открыт для вопросов и замечаний !
Одна тонкость :
  Данные для РасчетКС и соответсвенно Контролька подаются по 10 - 50 байт, может из-за этого ?
Система : P4-3.2 HT 512mb 2channel DDR 400, WinXP SP1
    1C:Предприятие вер. 25 сетевая - комплексная.
    Тестировал локально.

(75) а (23) не проверял?

(76) Только пришел домой, сразу налепил две обработочки - для сравнения. После результатов - кинулся смотреть почему ?
Видимо конкатенация и анализ строк в 1С быстрее, чем деление-умножение ???
Кто не верит, могу кинуть на мыло - 30 кг.
Обработки работают с любой конфой.
Щас попробую (23), но с wScript-aми совсем не дружу, результаты если появятся, то не сразу.
Здесь можно как-либо файлик выложить ? Или скриншот ?
Вставил бы сам в шаблон - все быстрее чем я.

+(77) Сейчас поковырял (23) и понял что ничего не понял.
Не знаю даже с какой стороны подступиться.
Попробуй пошагово объяснить что делать, если не в лом.

создай файл с расширением VBS как параметр передай имя файла из тойже директории (конечно лучче простой текст, но для сложности можно что попало), создаст файл имяфайлапреданногокакпараметрсрасширением.crc
там будут контрольные суммы всех строк в хексе...

+(79) используй (48)

(80) Запустил, алгоритм немного не тот.
контрольная сумма должна быть одна по всему файлу.
Результат расчета первой строки должен попасть на вход
к расчету второй строки в iPrevSumm
Пробовал поправить, ошибка сравнения типов :(
А главное, как мне результат к 1С прикрутить ?
И придется её из командной строки из 1С вызывать постоянно ?

(81) нет ненадо постоянно позже покажу, понял нужно результат строки запихивать в начало

подправил последний кусок (48) чтоб и общюю ЦРЦ вписывало
main
iPrevSummTemp=12504
If WScript.Arguments.Count > 0 Then
  Set f = fso.OpenTextFile(Wscript.arguments.item(0), ForReading, True)
  Set crc = fso.OpenTextFile(Wscript.arguments.item(0)&".crc", ForWriting, True)
  crcSTR=""
  Do While Not f.AtEndOfStream
    iPrevSummTemp=calcCRC16(iPrevSummTemp, f.ReadLine())
    crcSTR="" & hex(iPrevSummTemp) & vbCrLf & crcSTR
  loop
  crcONE=hex(iPrevSummTemp)
  crc.write crcSTR & vbCrLF & vbCrLF & "Вот и общая контролка " & crcONE
  crc.close
  f.close
else
  WScript.echo hex(calcCRC16(0, "kl;sfj ;lskdjf;dfj1"))
end if
...
чуть позже напишу как 1Сэ присобачить

(83) Работает !
Отдельно от 1С по времени вроде быстро, а если этой функции по 50 байт скармливать из 1С?
Смысл в том, что файл содержит в себе несколько секций со своими КС, а потом в конце считается общая КС по файлу.
Добавь только плз в первую и последнюю строку выходного файла текущее время, у меня нет секундомера в наличии :)

делаешь обработку на кнопку вешаешь сформировать(), длбавляешь поле ввода с кнопкой тип-строка, длинна 255
в модуле формы вот это (можно переделать и под "поток" строк не из файла, это уж силами 1Сэ)
....
Перем Путь, Имя;
//*******************************************
Процедура Сформировать(Файл)
     Попытка
          scrptCtrl=createobject("MSScriptControl.ScriptControl");
          scrptCtrl.language="vbscript";
          scrptCtrl.addcode("Dim iPrevSummTemp
  |Dim CRCTAB_16(255)
  |Const ForReading = 1
  |Const ForWriting = 2
  |'...
  |Sub main()
  | CRCTAB_16(0) = 0
  | For i = 1 To 255
  | CRCTAB_16(i) = CRCTAB_16(i - 1) + &H1021
  | Next
  |End Sub
  |' 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 значений
  |'...
  |Function calcCRC16(iPrevSumm, btArrStr)
  | For i = 1 To Len(btArrStr)
  | iPrevSumm = (CRCTAB_16(sdvigNew(iPrevSumm, 8, True) And 255) Xor sdvigNew(iPrevSumm, 8, False) Xor Asc(Mid(btArrStr, i, 1))) And 65535
  | Next
  | calcCRC16 = iPrevSumm
  |End Function
  |'...
  |Function sdvigNew(a, n, leftorright)
  | if a=0 then
  | sdvigNew = 0
  | exit function
  | else
  | at=2^(Int(Log(a) / Log(2)))+1
  | end if
  | if at<65535 then
  | at=65535
  | end if
  | if lefttoright then
  | res=a / (2 ^ n)
  | else
  | res=a * (2 ^ n) mod at
  | end if
  |sdvigNew = res
  |end function
  |'...
  |Function startCRC()
  |Call main
  |iPrevSummTemp=12504
  |Set fso = CreateObject(""Scripting.FileSystemObject"")
  | Set f = fso.OpenTextFile("""+Файл+""", ForReading, True)
  | Set crc = fso.OpenTextFile("""+Файл+"""&"".crc"", ForWriting, True)
  | crcSTR=""""
  | Do While Not f.AtEndOfStream
  | iPrevSummTemp=calcCRC16(iPrevSummTemp, f.ReadLine())
  | crcSTR="""" & hex(iPrevSummTemp) & vbCrLf & crcSTR
  | loop
  | crcONE=hex(iPrevSummTemp)
  | crc.write crcSTR & vbCrLF & vbCrLF & ""Вот и общая контролка "" & crcONE
  | crc.close
  | f.close
  |startCRC = crcONE
  |end function");
          Сообщить(scrptCtrl.run("startCRC"));
     Исключение
          Сообщить("Непонятки "+ОписаниеОшибки());
     КонецПопытки;
КонецПроцедуры
Процедура ПриНачалеВыбораЗначения(Идент,Флаг=1)
    Файл1="";
  фс.ВыбратьФайл(0,Файл1,Путь,,"*.*");
  Файл=Путь+Файл1;
КонецПроцедуры // ВыбратьФайл
Процедура ПриОткрытии()
    Имя = "";
    Путь = "";
    ПолноеИмя = РасположениеФайла(Путь, Имя);
КонецПроцедуры // ПриОткрытии

+(85) но тут ограничено время действия скрипта, так что лучче запускать внешний, но не командасистемы(), а темже WSH, а как вернуть параметры в 1Сэ позырю, делал...

файл ERT - Работало 741 мс., размер файла 25088, Терминал, не очень скоро вышло, но надо учесть время на Сообщить() да и работает с файлами на чтение и на запись, а не с "потоком" строк...
заменил Сообщить(scrptCtrl.run("startCRC"));
на следующее...(чтоб время считать)
  фс.АтрибутыФайла(Файл,РазмерФайла);
     ВремяНач=_GetPerformanceCounter();
          Состояние(scrptCtrl.run("startCRC"));
     ВремяКон=_GetPerformanceCounter();
     Сообщить("Работало "+(ВремяКон-ВремяНач)+" мс., размер файла "+РазмерФайла);

ну вот с внешним скриптом в 100!!! раз быстрее, вариант для 1Сэ (можно убрать создания файла, пусть все время будет)...
....
Перем Путь, Имя, РазмерФайла;
//*******************************************
Процедура Сформировать(Файл)
     Попытка
   WshShell = CreateObject("WScript.Shell");
          scrptCtrl=createobject("MSScriptControl.ScriptControl");
          scrptCtrl.language="vbscript";
     СтрокаДействия="Dim iPrevSummTemp
  |Dim CRCTAB_16(255)
  |Const ForReading = 1
  |Const ForWriting = 2
  |'...
  |Sub main()
  | CRCTAB_16(0) = 0
  | For i = 1 To 255
  | CRCTAB_16(i) = CRCTAB_16(i - 1) + &H1021
  | Next
  |End Sub
  |' 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, ....... // 256 значений
  |'...
  |Function calcCRC16(iPrevSumm, btArrStr)
  | For i = 1 To Len(btArrStr)
  | iPrevSumm = (CRCTAB_16(sdvigNew(iPrevSumm, 8, True) And 255) Xor sdvigNew(iPrevSumm, 8, False) Xor Asc(Mid(btArrStr, i, 1))) And 65535
  | Next
  | calcCRC16 = iPrevSumm
  |End Function
  |'...
  |Function sdvigNew(a, n, leftorright)
  | if a=0 then
  | sdvigNew = 0
  | exit function
  | else
  | at=2^(Int(Log(a) / Log(2)))+1
  | end if
  | if at<65535 then
  | at=65535
  | end if
  | if lefttoright then
  | res=a / (2 ^ n)
  | else
  | res=a * (2 ^ n) mod at
  | end if
  |sdvigNew = res
  |end function
  |'...
  |Function startCRC()
  |Call main
  |iPrevSummTemp=12504
  //| Wscript.echo iPrevSummTemp
  |Set fso = CreateObject(""Scripting.FileSystemObject"")
  | Set f = fso.OpenTextFile("""+СокрЛП(Файл)+""", ForReading, True)
  | Set crc = fso.OpenTextFile("""+СокрЛП(Файл)+""" &"".crc1"", ForWriting, True)
  | crcSTR=""""
  | Do While Not f.AtEndOfStream
  | iPrevSummTemp=calcCRC16(iPrevSummTemp, f.ReadLine())
  | crcSTR="""" & hex(iPrevSummTemp) & vbCrLf & crcSTR
  | loop
  | crcONE=hex(iPrevSummTemp)
  | crc.write crcSTR & vbCrLF & vbCrLF & ""Вот и общая контролка "" & crcONE
  | crc.close
  | f.close
  |startCRC = crcONE
  |end function
  |'End";
  Текст=СоздатьОбъект("Текст");
  СтрокаДействия=СтрЗаменить(СтрокаДействия,"'End","startCRC");
  Текст.ДобавитьСтроку(СтрЗаменить(СтрокаДействия,".crc1",".crc2"));
  Текст.Записать(Путь+"testCRC.vbs");
  Текст=СоздатьОбъект("Текст");
  СтрокаДействия2="Function RemoteCRC()
  |Set Controller = CreateObject(""WSHController"")
  |Set RemoteScript = Controller.CreateScript("""+Путь+"testCRC.vbs"")
  |ConnectObject RemoteScript, ""startCRC""
  |RemoteScript.Execute
  |Do While RemoteScript.Status <> 2
  |Sleep 100
  |Loop
  |DisconnectObject RemoteScript
  |End Function";
        scrptCtrl.addcode(СтрокаДействия);
  фс.АтрибутыФайла(Файл,РазмерФайла);
     ВремяНач=_GetPerformanceCounter();
          Сообщить(scrptCtrl.run("startCRC"));
     ВремяКон=_GetPerformanceCounter();
     Сообщить("Работало "+(ВремяКон-ВремяНач)+" мс., размер файла "+РазмерФайла);
     ВремяНач=_GetPerformanceCounter();
     oExec = WshShell.run("%WinDir%\System32\wscript.exe "+Путь+"testCRC.vbs");
     ВремяКон=_GetPerformanceCounter();
     Сообщить("Работало с внешним скриптом "+(ВремяКон-ВремяНач)+" мс., размер файла "+РазмерФайла);
     Исключение
          Сообщить("Непонятки "+ОписаниеОшибки());
     КонецПопытки;
КонецПроцедуры
Процедура ПриНачалеВыбораЗначения(Идент,Флаг=1)
    Файл1="";
  фс.ВыбратьФайл(0,Файл1,Путь,,"*.*");
  Файл=Путь+Файл1;
  фс.АтрибутыФайла(Файл,РазмерФайла);
КонецПроцедуры // ВыбратьФайл
Процедура ПриОткрытии()
    Имя = "";
    Путь = "";
    ПолноеИмя = РасположениеФайла(Путь, Имя);
КонецПроцедуры // ПриОткрытии
....
результаты на П4-2.8....
...
Работало 737 мс., размер файла 25088
Работало с внешним скриптом 6 мс., размер файла 25088
5180
Работало 746 мс., размер файла 25088
Работало с внешним скриптом 5 мс., размер файла 25088
5180
Работало 753 мс., размер файла 25088
Работало с внешним скриптом 7 мс., размер файла 25088
5180
Работало 737 мс., размер файла 25088
Работало с внешним скриптом 6 мс., размер файла 25088
5180
Работало 740 мс., размер файла 25088
Работало с внешним скриптом 5 мс., размер файла 25088

сменил -
oExec = WshShell.run("%WinDir%\System32\wscript.exe "+Путь+"testCRC.vbs");
на -
oExec = WshShell.Exec("%WinDir%\System32\wscript.exe "+Путь+"testCRC.vbs");
и вот еще в 3-4 раза быстрее стало )да файл неочч большой 20 кб и 394 строки) результаты (все иду спать):
Работало 743 мс., размер файла 25088
Работало с внешним скриптом 1 мс., размер файла 25088
5180
Работало 745 мс., размер файла 25088
Работало с внешним скриптом 2 мс., размер файла 25088
5180
Работало 741 мс., размер файла 25088
Работало с внешним скриптом 2 мс., размер файла 25088
5180
Работало 739 мс., размер файла 25088
Работало с внешним скриптом 1 мс., размер файла 25088
5180
Работало 739 мс., размер файла 25088
Работало с внешним скриптом 2 мс., размер файла 25088
5180
Работало 738 мс., размер файла 25088
Работало с внешним скриптом 2 мс., размер файла 25088

То smaharbA - Результаты говорят сами за себя !
Сажусь изучать работу с wScript. Спасибо !!!
На моем файле 4 сек. без WshShell.run() против
лучшего результата 1С - 8 сек.
То All : Тема исчерпана.
Модератору : Как закрыть ветку ?

(90) Изучай сразу С,С++ на нем еще быстрее будет

(90)
Перед публикацией сообщений следует сразу читать пост №0

Поправлю:
Сообщение 92 для (91).

(93) Это написано после цитаты из (90) "Сажусь изучать работу с wScript. Спасибо !!!"
Вся ветка имеет чисто спортивный интерес.
Каждый язык программирования имеет свое назначение и писать subj на
1c это как анектот про гланды

Для Z1:
Автор этой ветки - Klio.
Поэтому всё же читать пост №0 следует:)

(95) Автор поста (90) тоже Kilo. В течении обсуждения от 0 до 90
автор ветки пришел к выводу что решить задачу (0) лучше на wsh.
я же его автора Kilo прошу обратить внимание что на языке "С" будет
работать на порядок быстрее чем на wsh и ничего более о чем кстати тоже говорилось в некоторых постах. Больше в эту ветку не буду писать а то уже неконструктивный разговор пошел :))).