Нещо съм блокирал май...
Има ли елегантен начин за размяна само на битове 7<->8, 6<->9, 5<->11, 4<->12, без да се закачат останалите, в един unsigned int?
Сигурен съм че има, ама в момента ми убягва.

с таблица ще стане най-лесно и най-бързо

За много платформи има инструкции за byte order (REV) и bit order (RBIT), доколкото схващам ти трябват и двете, т.е.

unsigned int foo(unsigned int x)
{
return __RBIT(__REV16(x))>>16;
}

евентуално foo може да е inline и ако компилираш с Ц++ може да е constexpr.

Те всъщност са 8 бита - просто трябва първо да >>4 после обръщаш битовете в целия байт и накрая <<4. Обръщането според архитектурата - ако има CPU инструкция добре, ако не с таблица.

Верно ли само изброените битове? Че и с дупка

Значи нещо от сорта:

Всъщност размяната даже е малко по сложна отколкото я описах
В едната посока е 4->7, 5->8, 6->9, 7->10
В другата е 7->11, 6->10, 5->9, 4->8

След приличен обяд успях да вържа някакъв код, ама тепърва ще го пробвам... (k[r] ми е 16-битовото число)



като xb[] табличката е

Е не е по-сложно... това за каква платформа е? Питам щото ако е arm както си го написал е супер неефективно

Arm?? Тва пък какво е? (подразбира се че не е...)
Виж сега, аз не се смятам за велик програматор. Моята философия е по-обща.
Ако си в настроение да ми подобриш кода, ще ти благодаря (между псувните че не съм се сетил сам )

За съжаление кристалното ми кълбо се повреди и няма как да разбера какъв тип архитектура и какъв компилатор ползваш.

Ми да беше споменал. Аз съм зарит от кристални кълба дето не ги ползвам. Пик16 ми е архитектурата за това и ХС8 компилатор

Ти направо ме закопа... не съм ги чувал тия

Единственото дето знам е че май са 8-бит... Компилаторът пък хептен нищо не ми говори, все пак ако е добър в оптимизациите може би не трябва да му се пречкаш с междинни променливи. Пробвай с един голям израз директно да му дадеш резултата пък той да си преценява

т.е. нещо от сорта:

k[r]=(k[r] & 0xf00f) | ((k[r] & 0xf0) << 4 ) | ((unsigned int)xb[(k[r]>>8) & 0xf] << 4);

Просто виж какъв асемблер генерира и прецени. Ак о с общия израз e добре, може да го подобриш още като преместиш последния шифт от кода в таблицата. Тя нали е 8 битова, т.е. да шифтнеш стойностите й.

/*-------------------------------------------------------------------------
* Some useful macros for inline assembly stuff
*-------------------------------------------------------------------------*/
#define Nop() {_asm nop _endasm}
#define ClrWdt() {_asm clrwdt _endasm}
#define Sleep() {_asm sleep _endasm}
#define Reset() {_asm reset _endasm}

#define Rlcf(f,dest,access) {_asm movlb f rlcf f,dest,access _endasm}
#define Rlncf(f,dest,access) {_asm movlb f rlncf f,dest,access _endasm}
#define Rrcf(f,dest,access) {_asm movlb f rrcf f,dest,access _endasm}
#define Rrncf(f,dest,access) {_asm movlb f rrncf f,dest,access _endasm}
#define Swapf(f,dest,access) {_asm movlb f swapf f,dest,access _endasm }

виж какво прави последния ред

Последния ред, а и предните 4, са за пик18. Човека търси решение за пик16.
@Н'бабане, ако те устройва на асемблер мога да бутна едно рамо

Повечето МП архитектури имат инструкция за размени тетрадите в байта. Та май такава ти трябва.
SWAP в x51. При пиковете-ненам.

@CarBeta, мерси настина, но няма да ми трябва асемблер. Всъщност аз съм го загърбил от години вече и винаги гледам да мина по най-правата крива
В общи линии това което съм сътворил ми върши работа, оттук нататък всички оптимизации ще са единствено за спорта.