[MrYuran 21]

Если честно, не впечатлило. Букаф зело много. В сравнении с сишным

пресловутого лаконизма исходного кода не замечено.

Ну почему же, вот:

: crc ( n ch--n)  >< XOR 
                  8 0 DO  DUP 8000 AND  
                          IF  2* FFFF AND  crc-polynomial XOR
                        ELSE  2* 
                        THEN
                    LOOP;

Может, на более мелкие слова разбить можно.

[Kopa 0]

Не, я вовсе не к тому, что Forth vs C, а просто хотелось бы какой-нить пример, который реально показывает преимущества форта, чтоб понять его мощь.

 

Вспоминается ситуация со слепыми мудрецами и слоном:)

[Rst7 5]

P.S. Расчёт CRC ещё для увеличения скорости алгоритма часто реализовывают на asm

 

Для увеличения скорости сначала крепко думают над алгоритмом. Например, для фиксированного полинома от Modbus все делается так (пардон за непортабельный код)

__z UREG CRC16stage2(UINT8 uchCRCLo, UINT8 uchCRCHi, UREG l, UREG write, UINT8 *puchMsg, UREG i128,UREG i1, UREG i192);

UREG CRC16(UINT8 *puchMsg, UREG usDataLen, UREG write )
{
 return CRC16stage2(0xFF,0xFF,usDataLen,write,puchMsg,128,1,192);
}

#pragma optimize=no_inline
__z UREG CRC16stage2(UINT8 uchCRCLo, UINT8 uchCRCHi, UREG l, UREG write, UINT8 *puchMsg, UREG i128, UREG i1, UREG i192)
{
 if (l)
 do
 {
   UINT8 parity;
   UINT16 tmp16;
   parity=*puchMsg++;
   parity^=uchCRCLo;
   uchCRCLo=uchCRCHi;
   tmp16=__multiply_unsigned(parity,i128);
   uchCRCHi=tmp16>>8;
   uchCRCLo^=tmp16;
   //tmp16=__multiply_unsigned(parity,i64);
   tmp16>>=1;
   uchCRCHi^=tmp16>>8;
   uchCRCLo^=tmp16;
   parity^=tmp16>>8;
   parity^=parity>>1;
   parity^=__swap_nibbles(parity);
   if (parity&1)
   {
     uchCRCLo^=i1;
     uchCRCHi^=i192;
   }
 }
 while(--l);
 if (write)
 {
   *puchMsg++=uchCRCLo;
   *puchMsg++=uchCRCHi;
 }
 else
 {
   UREG k;
   if ((k=*puchMsg++-uchCRCLo)) return k;
   return *puchMsg++-uchCRCHi;
 }
 return 0;  
}

 

или для полинома 0x11021

//Полный подсчет за один раз
void PGMCRC(void)
{
 unsigned long p;
 char h12=0;
 char h0=0;
 char h1;
 char hl5;
 char hh5;

 p=0;
 do
 {
   h1=h12; 				//F  E  D  C  B  A  9  8
   h12=__swap_nibbles(h12);		//B  A  9  8  F  E  D  C
   hh5=h12;				//B  A  9  8  F  E  D  C
   h12^=h1;				//FB EA D9 C8 BF AE 9D 8C
   h12&=0xF0;				//FB EA D9 C8 _  _  _  _
   hh5&=0x0F;				//_  _  _  _  F  E  D  C
   h1^=hh5;				//F  E  D  C  FB EA D9 C8
   hl5=h12;				//FB EA D9 C8 _  _  _  _
   {
     unsigned int i=(hh5<<8)|hl5;	//_  _  _  _  F  E  D  C  FB EA D9 C8 _  _  _  _
     i<<=1;
     hh5=i>>8;			//_  _  _  F  E  D  C  FB
     hl5=(char)i;			//                        EA D9 C8 _  _  _  _  _
   }
   h1^=hl5; //crclo		//                                FEA ED9 DC8 C   FB  EA  D9  C8
   h12^=hh5; //crchi		//FB  EA  D9  FC8 E   D   C   FB

   h12^=h0;
#pragma diag_suppress=Pe1053
   h0=h1^(p<0x1FFFE?(*(char __farflash *)p):0);
#pragma diag_default=Pe1053
   p++;
#ifdef PUA1
   if (!((char)p))
   {
     if (PORTA&8) PORTA&=~8; else PORTA|=8;
   }
#endif
 }
 while(p<0x20000);
#pragma diag_suppress=Pe1053
 if(((h12<<8)|h0)!=*(unsigned int __farflash *)0x1FFFE)
 {
   //Ошибка контрольной суммы
   __disable_interrupt();
   __watchdog_reset();
   WDTCR=0x08;
   WDTCR=0x18;
   WDTCR=0x0A; //Разрешаем сторожевой таймер
   __watchdog_reset();
   for(;;);
 }
#pragma diag_default=Pe1053
}

 

А потом уже фалосоизмерением занимаются

 

Это я так, мысли вслух. Не подумайте, ничего личного :)

[Kopa 0]

Для увеличения скорости сначала крепко думают над алгоритмом.

Например, для фиксированного полинома от Modbus все делается так (пардон за непортабельный код)

 

Можно и так:

//***************************************************************************
//	Расчёт CRC16
//***************************************************************************
static const unsigned int wCRCTable[] = {
0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241,
0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440,
0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40,
0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841,
0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40,
0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41,
0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641,
0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040,
0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240,
0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441,
0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41,
0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840,
0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41,
0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40,
0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640,
0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041,
0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240,
0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441,
0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41,
0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840,
0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41,
0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40,
0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640,
0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041,
0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241,
0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440,
0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40,
0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841,
0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40,
0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41,
0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641,
0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };

unsigned int CRC16 ( unsigned char *nData, unsigned int wLength)
{
unsigned char nTemp;
unsigned int wCRCWord = 0xFFFF;

  while (wLength--)
  {
  nTemp = *nData++ ^ wCRCWord;
  wCRCWord >>= 8;
  wCRCWord ^= wCRCTable[nTemp];
  }
  return wCRCWord;
}


unsigned int  U_CRC16 (unsigned int lngth)
{
  unsigned char *item=&UART_RxBuf[0];//Я убрал (было в передаваемых параметрах)
unsigned int CRC = 0xFFFF;
unsigned char  i;

 while (lngth--)
 {
CRC ^= *item++; 

for (i=8;i>0;i--)
  if (CRC & 1)  { CRC >>= 1; CRC ^= 0xA001; }
  else		  { CRC >>= 1; }


 }

return (CRC);
}

 

P.S. Скорость, при использовании, не измерял:)

Изменено 28 мая, 2009 пользователем Kopa

[forever failure 0]

Вспоминается ситуация со слепыми мудрецами и слоном:)

О, умудрённый, скажите, в каком месте нужно смеяццо ?

То что CRC можно посчитать миллион сто одним способом, на асме, С, паскале, чём угодно - это и так ясно, и опять таки алгоритм и средство его реализации выбирается исходя из конкретных условий.

Я то что хочу увидеть - для какой практической задачи решение на форте реально красиво настолько, насколько его (форт) тут расписывают.

А Вы всё про шашечки и рюшечки. CRC на асме я и сам напишу, - невелика наука.

 

всё, про форт, похоже забыли, началась фаллометрия на Ц.

[Kopa 0]

А потом уже фалосоизмерением занимаются

Это я так, мысли вслух. Не подумайте, ничего личного :)

 

Самое неблагодарное занятие.

[Rst7 5]

Самое неблагодарное занятие.

 

А я и не занимаюсь. Я так, намекаю...

[Kopa 0]

всё, про форт, похоже забыли, началась фаллометрия на Ц.

 

Согласен.

 

Но красиво или нет то или иное решение - это уже субъективная точка зрения:)

и в реализации на выбранном языке уже присутствует опосредовано:)

[ukpyr 0]

ого, какие простыни...

вот еще короче :

#define inc_crc16_modbus_upd(data, crc_prev) { \
    U8 cnt_bits, flag_xor; \
    crc_prev ^= data; \
    for (cnt_bits = 8; cnt_bits; cnt_bits--) { \
        flag_xor = crc_prev & 1; \
        crc_prev >>= 1; \
        if (flag_xor) crc_prev ^= CRC16_MODBUS_POLY_VALUE; \
    } \
}

 

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

 

я думаю основное преимущество Форта - в режиме интерпретатора, например как более эффективная альтернатива обучающим средствам типа Bascom-AVR. Когда работу юзера можно организовать в консоли терминала, подключенной к посл.пору контроллера.

Изменено 28 мая, 2009 пользователем ukpyr

[forever failure 0]

Всё, всё, хватит про CRC. Будем считать, что на форте получается не хуже, в любом смысле.

[Kopa 0]

Я то что хочу увидеть - для какой практической задачи решение на форте реально красиво настолько,

насколько его (форт) тут расписывают.

 

Возможно это самый трудно объяснимый феномен Форта,

( и понимание может быть своё и даже иррациональное )

 

но например имеется проект AI на Форте

и небольшое обсуждение

Forth vs Python частного проекта "Вырастим искусственный интеллект"

 

P.S. Главное понятие в языке - это слово!

 

но согласитесь, если алгоритм более сложный (напр.какие-то расчеты и т.д.), разобраться в нем с первого взгляда на порядок сложнее чем в С.

 

Для этого расширяют язык обычной формой записи арифметических выражений:)

А с пониманием произвольного алгоритма по реализации могут быть проблемы.

 

P.S. Разбираться в алгоритме не сложно, если оно требуется

( ищется именно то место где возникли определённые проблемы по использованию )

Много кода даже и не рассматривается.

Форт - это "айсберг" о существовании которого многие даже и не догадываются:)

 

Пока.

Изменено 28 мая, 2009 пользователем Kopa

[MrYuran 21]

На данном форуме тем, полезных для прочтения по Форту, не присутствует.

Эта, наверное, первое хорошее обсуждение.:)

 

Уже оживил обсуждение данного топика, хотя гуру или нет не знаю.

Ждёмс появления интереса?

:smile3046:

Я думаю по этому поводу вот что:

Нужно, чтобы была готовая система по принципу "включил и работай".

И продвигать среди людей, не испорченных разными сями.

Наверняка начинающие оценят такой синтаксис:

АЦП Запустить
BEGIN 
    Подождать
    АЦП ?Готово 
UNTIL 
АЦП Считать
Температуру Вычислить

 

Особенно, если каждое слово можно выдать с терминала и тут же получить результат.

[Rst7 5]

Наверняка начинающие оценят такой синтаксис:

 

Я так понимаю, Вы о Domain Specific Language. На больших братьях - в полный рост применяется.

[Kopa 0]

Наверняка начинающие оценят такой синтаксис:

АЦП Запустить
BEGIN 
    Подождать
    АЦП ?Готово 
UNTIL 
АЦП Считать
Температуру Вычислить

 

Особенно, если каждое слово можно выдать с терминала и тут же получить результат.

 

Существует дипломный проект браузера здесь

почти всё в нём в русских словах, но не всё выглядит однозначно.

 

1. Требуется более тщательное продумывание способов этого использования.

( например по оформлению кода )

2. Использование длинных слов плохо сказывается на восприятии программы.

3. Если не принять дополнительных мер по различению слов из разных

семантических групп, то это тоже влияет на восприятие.

...

 

 

 

 

 

Я так понимаю, Вы о Domain Specific Language. На больших братьях - в полный рост применяется.

 

И какие ещё есть общеупотребительные DSL если исключить из списка SQL?

 

P.S. Реализации в Форте разных концепций зачастую и есть DSL, но с

чертами Форт направленности.

[Rst7 5]

И какие ещё есть общеупотребительные DSL если исключить из списка SQL?

 

Ну я бы не ставил язык запросов в один ряд с DSL. Все-таки DSL - это язык, делающийся под конкретную систему (программную или программно-аппаратную). На то он и Domain Specific. Форт обладает хорошими возможностями для упрощения построения таких языков. Хотя, я бы еще поспорил, где проще. Вот, например, обожаемый в современном функциональном программировании Хаскель

 

{-# OPTIONS_GHC -fno-warn-type-defaults #-}
{-# LANGUAGE ExtendedDefaultRules, OverloadedStrings #-}
module Hello where
import Language.BASIC

main :: IO ()
main = runBASIC $ do

    10 PRINT "Hello BASIC World!"