for (ss=seed&(MM-1),t=TT-1; t; ) {       
    for (j=KK-1;j>0;j--) x[j+j]=x[j], x[j+j-1]=0; /* "square" */
    for (j=KK+KK-2;j>=KK;j--)
      x[j-(KK-LL)]=mod_diff(x[j-(KK-LL)],x[j]),
      x[j-KK]=mod_diff(x[j-KK],x[j]);
    if (is_odd(ss)) {              /* "multiply by z" */
      for (j=KK;j>0;j--)  x[j]=x[j-1];
      x[0]=x[KK];            /* shift the buffer cyclically */
      x[LL]=mod_diff(x[LL],x[KK]);
    }
    if (ss) ss>>=1; else t--;
  }

  for (ss=seed&(MM-1),t=TT-1; t; ) {       
    for (j=KK-1;j>0;j--) x[j+j]=x[j], x[j+j-1]=0; /* "square" */
    for (j=KK+KK-2;j>=KK;j--)
      x[j-(KK-LL)]=mod_diff(x[j-(KK-LL)],x[j]),
      x[j-KK]=mod_diff(x[j-KK],x[j]);
    if (is_odd(ss)) {              /* "multiply by z" */
      for (j=KK;j>0;j--)  x[j]=x[j-1];
      x[0]=x[KK];            /* shift the buffer cyclically */
      x[LL]=mod_diff(x[LL],x[KK]);
    }
    if (ss) ss>>=1; else t--;
  }

Q1:    if (N<=M) goto Q9; S=0; l=1; r=N;
Q2:    i=l; j=r+1; K=R[l]->K;
Q3:    i+=1; if (R[i]->K<K) goto Q3;
Q4:    j-=1; if (K<R[j]->K) goto Q4;
Q5:    if (j<=i) { swap(R[l],R[j],Rt); goto Q7; }
Q6:    swap(R[i],R[j],Rt); goto Q3;
Q7:    if (r-j>=j-l>M) { push(j+1,r); S+=1; r=j-1; goto Q2; }
       if (j-l>r-j>M) { push(l,j-1); S+=1; l=j+1; goto Q2; }
       if (r-j>M>=j-l) { l=j+1; goto Q2; }
       if (j-l>M>=r-j) { r=j-1; goto Q2; }
Q8:    if (S) { pop(l,r); S-=1; goto Q2; }
Q9:    for (j=2; j<=N; j+=1) {
           if (R[j-1]->K > R[j]->K) {
               K=R[j]->K; Rt=R[j]; i=j-1; R[i+1]=R[i];
                   while (R[i]->K>K && i>=1) i-=1;
                   R[i+1]=Rt; } }

template <class T> 
void QuickSort(T & item, int left, int right)
{
    int i = left;
    int j = right;  
    typename T::value_type center = item[(left + right) / 2];

    while(i <= j)
    {
        while (less(item[i], center))
            i++;
        while (less(center, item[j]))
            j--;

        if (i <= j)
            Swap(item[i++], item[j--]);
    } 

    if(left < j)
        QuickSort(item, left, j);
    if(right > i)
        QuickSort(item, i, right);
}

But the reasons for machine language that I gave in the preface to Volume 1, written in the early 1960s, remain valid today:

• One of the principal goals of my books is to show how high-level constructions are actually implemented in machines, not simply to show how they are applied. I explain coroutine linkage, tree structures, random number generation, high-precision arithmetic, radix conversion, packing of data, combinatorial searching, recursion, etc., from the ground up.
  
• The programs needed in my books are generally so short that their main points can be grasped easily.
  
• People who are more than casually interested in computers should have at least some idea of what the underlying hardware is like. Otherwise the programs they write will be pretty weird.
  
• Machine language is necessary in any case, as output of many of the software programs I describe.
  
• Expressing basic methods like algorithms for sorting and searching in machine language makes it possible to carry out meaningful studies of the effects of cache and RAM size and other hardware characteristics (memory speed, pipelining, multiple issue, lookaside buffers, the size of cache blocks, etc.) when comparing different schemes.

Moreover, if I did use a high-level language, what language should it be? In the 1960s I would probably have chosen Algol W; in the 1970s, I would then have had to rewrite my books using Pascal; in the 1980s, I would surely have changed everything to C; in the 1990s, I would have had to switch to C++ and then probably to Java. In the 2000s, yet another language will no doubt be de rigueur. I cannot afford the time to rewrite my books as languages go in and out of fashion; languages aren't the point of my books, the point is rather what you can do in your favorite language. My books focus on timeless truths.

Therefore I will continue to use English as the high-level language in TAOCP, and I will continue to use a low-level language to indicate how machines actually compute. Readers who only want to see algorithms that are already packaged in a plug-in way, using a trendy language, should buy other people's books.

{4:}{9:}{$C-,A+,D-}{[$C+,D+]}{:9}PROGRAM TEX;LABEL{6:}1,9998,9999;{:6}
CONST{11:}MEMMAX=30000;MEMMIN=0;BUFSIZE=500;ERRORLINE=72;
HALFERRORLIN=42;MAXPRINTLINE=79;STACKSIZE=200;MAXINOPEN=6;FONTMAX=75;
FONTMEMSIZE=20000;PARAMSIZE=60;NESTSIZE=40;MAXSTRINGS=3000;
STRINGVACANC=8000;POOLSIZE=32000;SAVESIZE=600;TRIESIZE=8000;
TRIEOPSIZE=500;DVIBUFSIZE=800;FILENAMESIZE=40;
POOLNAME='TeXformats:TEX.POOL                     ';{:11}TYPE{18:}
ASCIICODE=0..255;{:18}{25:}EIGHTBITS=0..255;
ALPHAFILE=PACKED FILE OF CHAR;BYTEFILE=PACKED FILE OF EIGHTBITS;{:25}
{38:}POOLPOINTER=0..POOLSIZE;STRNUMBER=0..MAXSTRINGS;
PACKEDASCIIC=0..255;{:38}{101:}SCALED=INTEGER;
NONNEGATIVEI=0..2147483647;SMALLNUMBER=0..63;{:101}{109:}GLUERATIO=REAL;
{:109}{113:}QUARTERWORD=0..255;HALFWORD=0..65535;TWOCHOICES=1..2;
FOURCHOICES=1..4;TWOHALVES=PACKED RECORD RH:HALFWORD;
CASE TWOCHOICES OF 1:(LH:HALFWORD);2:(B0:QUARTERWORD;B1:QUARTERWORD);
END;FOURQUARTERS=PACKED RECORD B0:QUARTERWORD;B1:QUARTERWORD;
B2:QUARTERWORD;B3:QUARTERWORD;END;

define exit = 10 { go here to leave a procedure } 
define restart = 20 { go here to start a procedure again } 
define reswitch = 21 { go here to start a case statement again } 
define continue = 22 { go here to resume a loop } 
define done = 30 { go here to exit a loop } 
define found = 31 { go here when you’ve found it } 
define not found = 32 { go here when you’ve found something else }

/*:52*//*57:*/
#line 792 "ctangle.w"
{
int c;
for(c= 0;c<256;c++)ccode[c]= ignore;
ccode[' ']= ccode['\t']= ccode['\n']= ccode['\v']= ccode['\r']= ccode['\f']
= ccode['*']= new_section;
ccode['@']= '@';ccode['=']= string;
ccode['d']= ccode['D']= definition;
ccode['f']= ccode['F']= ccode['s']= ccode['S']= format_code;
...

SC>/*:52*//*57:*/
SC>#line 792 "ctangle.w"
SC>{
SC>int c;
SC>for(c= 0;c<256;c++)ccode[c]= ignore;
SC>ccode[' ']= ccode['\t']= ccode['\n']= ccode['\v']= ccode['\r']= ccode['\f']
SC>= ccode['*']= new_section;
SC>ccode['@']= '@';ccode['=']= string;
SC>ccode['d']= ccode['D']= definition;
SC>ccode['f']= ccode['F']= ccode['s']= ccode['S']= format_code;
SC>...
SC>

if( some_thing_with_long_name + something_else_with_long_name + yet_another_beast
    == not_very_short_name_too() + something_else )
    ...

std::cout << some_thing_with_long_name << " + "
    << something_else_with_long_name << " + "
    << yet_another_beast << std::endl;

if (ss) ss>>=1; t--;
if (ss) ss>>=1; else t--;

V>Насчет наименований переменных — так же. С длинными именами приведенное выше выражение может просто не влезть в одну строку целиком. Да и программы с короткими идентификаторами банально быстрее компилировались

E>if( some_thing_with_long_name + something_else_with_long_name + yet_another_beast
E>    == not_very_short_name_too() + something_else )
E>    ...
E>

E>std::cout << some_thing_with_long_name << " + "
E>    << something_else_with_long_name << " + "
E>    << yet_another_beast << std::endl;
E>

a = b + c
      + d;

a = b + c +
        d;

SC>/*:52*//*57:*/
SC>#line 792 "ctangle.w"
SC>{
SC>int c;
SC>for(c= 0;c<256;c++)ccode[c]= ignore;
SC>ccode[' ']= ccode['\t']= ccode['\n']= ccode['\v']= ccode['\r']= ccode['\f']
SC>= ccode['*']= new_section;
SC>ccode['@']= '@';ccode['=']= string;
SC>ccode['d']= ccode['D']= definition;
SC>ccode['f']= ccode['F']= ccode['s']= ccode['S']= format_code;
SC>...
SC>

% This file is part of CWEB.
% This program by Silvio Levy and Donald E. Knuth
% is based on a program by Knuth.

@ Important milestones are reached during the input phase when certain
control codes are sensed.

Control codes in \.{WEB} begin with `\.{@@}', and the next character
identifies the code. Some of these are of interest only to \.{WEAVE},
so \.{TANGLE} ignores them; the others are converted by \.{TANGLE} into
internal code numbers by the |control_code| function below. The ordering
of these internal code numbers has been chosen to simplify the program logic;
larger numbers are given to the control codes that denote more significant
milestones.

@d ignore=0 {control code of no interest to \.{TANGLE}}
@d control_text=@'203 {control code for `\.{@@t}', `\.{@@\^}', etc.}
@d format=@'204 {control code for `\.{@@f}'}
@d definition=@'205 {control code for `\.{@@d}'}
@d begin_Pascal=@'206 {control code for `\.{@@p}'}
@d module_name=@'207 {control code for `\.{@@<}'}
@d new_module=@'210 {control code for `\.{@@\ }' and `\.{@@*}'}

@p function control_code(@!c:ASCII_code):eight_bits; {convert |c| after \.{@@}}
begin case c of
"@@": control_code:="@@"; {`quoted' at sign}
"'": control_code:=octal; {precedes octal constant}
"""": control_code:=hex; {precedes hexadecimal constant}
"$": control_code:=check_sum; {string pool check sum}
" ",tab_mark: control_code:=new_module; {beginning of a new module}
"*": begin print('*',module_count+1:1);
  update_terminal; {print a progress report}
  control_code:=new_module; {beginning of a new module}
  end;
"D","d": control_code:=definition; {macro definition}
"F","f": control_code:=format; {format definition}
"{": control_code:=begin_comment; {begin-comment delimiter}
"}": control_code:=end_comment; {end-comment delimiter}
"P","p": control_code:=begin_Pascal; {\PASCAL\ text in unnamed module}
"T","t","^",".",":": control_code:=control_text; {control text to be ignored}
"&": control_code:=join; {concatenate two tokens}
"<": control_code:=module_name; {beginning of a module name}
"=": control_code:=verbatim; {beginning of \PASCAL\ verbatim mode}
"\": control_code:=force_line; {force a new line in \PASCAL\ output}
othercases control_code:=ignore {ignore all other cases}
endcases;
end;

% This program by D. E. Knuth is not copyrighted and can be used freely.
% Version 0 was released in December, 1981.
% Version 1 was released in September, 1982, with version 0 of TeX.
% Slight changes were made in October, 1982, for version 0.6 of TeX.
% Version 1.2 introduced {:nnn} comments, added @@= and @@\ (December, 1982).
% Version 1.4 added "history" (February, 1983).
% Version 1.5 conformed to TeX version 0.96 and fixed @@\ (March, 1983).
% Version 1.7 introduced the new change file format (June, 1983).
% Version 2.0 was released in July, 1983, with version 0.999 of TeX.
% Version 2.5 was released in November, 1983, with version 1.0 of TeX.
% Version 2.6 fixed a bug: force-line-break after a constant (August, 1984).
% Version 2.7 fixed the definition of check_sum_prime (May, 1985).
% Version 2.8 fixed a bug in change_buffer movement (August, 1985).
% Version 2.9 allows nonnumeric macros before their def (December, 1988).
% Version 3, for Sewell's book, fixed long-line bug in input_ln (March, 1989).
% Version 4 was major change to allow 8-bit input (September, 1989).
% Version 4.1 conforms to ANSI standard for-loop rules (September, 1990).
% Version 4.2 fixes stat report if phase one dies (March, 1991).
% Version 4.3 fixes @@ bug in verbatim, catches extra } (September, 1991).
% Version 4.4 activates debug_help on errors as advertised (February, 1993).

VD>if (ss) ss>>=1; t--;
VD>if (ss) ss>>=1; else t--;
VD>

int tmp=a; a=b; b=tmp; // swap values

if (ss) 
{
    ss>>=1; 
}
else
{
    t--;
}

V>int tmp=a; a=b; b=tmp; // swap values
V>

Swap(&a, &b);

...

void Swap(int * a, int * b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

V>if (ss) 
V>{
    ss>>>=1; 
V>}
V>else
V>{
V>    t--;
V>}
V>

if (someBits != 0)
    someBits >>= 1;
else
    counter--;

V>Замечу, программы тех времен удивительно эффективны по современным реалиям. Понимаешь, техника не позволяла халтурить

V> Вот уж где можно было бы получить настоящее повторное использование кода. Подобная модель для кодогенерации была бы шаблоном уже сама по своей сути. А мы тут спорим — шаблоны С++ vs генерики

V>>int tmp=a; a=b; b=tmp; // swap values
V>>

VD>Swap(&a, &b);
VD>void Swap(int * a, int * b)
VD>{
VD>    int temp = *a;
VD>    *a = *b;
VD>    *b = temp;
VD>}
VD>

VD>

unsigned short tmp=a; a=b; b=tmp;

VD>if (someBits != 0)
VD>    someBits >>= 1;
VD>else
VD>    counter--;
VD>

Swap(&a, &b);

...

void Swap(int * a, int * b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

VD>

using System;
using System.Collections;

namespace MedicalForm
{
    public class DBHashElement
    {
        public int Key;
        public object Value;
        
        public DBHashElement()
        {
        }
        
        public DBHashElement(int key, object value)
        {
            Key = key;
            Value = value;
        }
    }
    
    public class DBHashEnumerator : IEnumerator

using System;
using System.Collections;

namespace MedicalForm
{
    public class DBHashElement
    {
        public int Key; public object Value;
        public DBHashElement(){}
        public DBHashElement(int key, object value){ Key = key; Value = value;|// <- граница экрана
    }
    public class DBHashEnumerator : IEnumerator
    {
        private IDictionaryEnumerator _enumerator = null;
        public DBHashEnumerator(Hashtable hashtable) { _enumerator = hashtable|// <- граница экрана
        public object Current { get { return new DBHashElement((int)_enumerato|// <- граница экрана
        public bool MoveNext() { return _enumerator.MoveNext(); }
        public void Reset() { _enumerator.Reset(); }
    }
    public class DBHash : IEnumerable
    {
        private Hashtable _hashtable = new Hashtable();

VD>Конечно. Это имеет отношение всего лишь к пониманию этих алгоритмов другими.

VD>И рано или поздно будет глюкодром вроде МС Ворд.

A>Однозначно мешало. Речь недвусмысленно шла о временах, когда время вызова функции было сопоставимо со временем работы алгоритма. Думаю ключевого слова inline тогда не было

A>Нет-нет. Думать впереди времени способны только Водолеи (вот у IT спроси), а ты у нас Телец, так что не верю

Пусть M = (Q, T, D, q0, F) — НКА

A>На LCD мониторе в 19" Влад, давай я тебе покажу кусок кода, каким бы он был виден на экране тех времён 80х25.

VD>>И рано или поздно будет глюкодром вроде МС Ворд.

A>MSWord у меня замечательно работает Так что аргумент какой-то не такой

A> Ни о какой поддержке без автора программы и речи не было Думаешь тот эмулятор опкоды через ADO читал?

#define swap(type, a, b) type temp = a; b = b; b = temp;

swap(int, a, b)
swap(int, a, b) <- очень непонятная ошибка компиляции.

A>>На LCD мониторе в 19" Влад, давай я тебе покажу кусок кода, каким бы он был виден на экране тех времён 80х25.

A>>MSWord у меня замечательно работает Так что аргумент какой-то не такой

VD>Swap(&a, &b);

VD>...

VD>void Swap(int * a, int * b)
VD>{
VD>    int temp = *a;
VD>    *a = *b;
VD>    *b = temp;
VD>}
VD>

VD>

if(...) {
   ...
   ...
} else {
   ...
   ...
}

V>>if (ss) 
V>>{
    ss>>>>=1; 
V>>}
V>>else
V>>{
V>>    t--;
V>>}
V>>

if (ss)
   ss >>= 1;
else
   t--;

VD>if (someBits != 0)
VD>    someBits >>= 1;
VD>else
VD>    counter--;
VD>

VD>Конечно. Это имеет отношение всего лишь к пониманию этих алгоритмов другими.

VD>О, нет. В этом случае только его часть окажется медленее оптимального. Причем воможно это даже никак не скажется на все ПО в целом. А вот если начинать халтурить с имен переменных и форматирования кода, то код конечно заработает, и возможно даже будет работать оптимально быстро. Но вот развивать его уже будет невозможно. И рано или поздно будет глюкодром вроде МС Ворд.

V>>Замечу, программы тех времен удивительно эффективны по современным реалиям. Понимаешь, техника не позволяла халтурить

VD>Уж не в TV ли? Это все таки ГУЕ-вая (вернее ТУЕ-вая) библиотека. Уж эмуляторам она никак не могла помочь.

VD>Ну, тогда просто согласись, с тем что это банальный прогресс. Я конечно понимаю, что раньше трава была голубее, а небо зеленее, но это просто скушно занудство. Когдм мне было 20 я терпеть не мог тридцатилетних "стриков" которые зудели о зелености травы. Вот сейчас периодически самому хочется позудеть, но я понимаю, что это в себе нужно давить. и давлю.

V>> Вот уж где можно было бы получить настоящее повторное использование кода. Подобная модель для кодогенерации была бы шаблоном уже сама по своей сути. А мы тут спорим — шаблоны С++ vs генерики

  for(int t=T; i+T<size; i++)
  {
    float f1 = 2 * (x[t+T/4] - x[t-T/4]);
    float f2 = -x[t+T/2] + 2*x[t] - x[t-T/2];
    env[t] := sqrt(f1*f1 + f2*f2);
    phi[t] := atan2(f2,f1);
  }

  for(int Frame=Period; Frame+Period<FrameCount; Frame++)
  {
    float FirstFilterFunctionInHylbertTransform = 2 * (Pinhole[Frame+Period/4] - Pinhole[Frame-Period/4]);
    float SecondFilterFunctionInHylbertTransform = -Pinhole[Frame+Period/2] + 2*Pinhole[Frame] - Pinhole[Frame-Period/2];
    Envelope[Frame] := sqrt(sqr(FirstFilterFunctionInHylbertTransform) + sqr(SecondFilterFunctionInHylbertTransform));
    TotalPhase[Frame] := atan2(SecondFilterFunctionInHylbertTransform,FirstFilterFunctionInHylbertTransform);
  }

 cC:= +(Poly(U, [-0.0007927,  0.0002548,  0.0000091]))*sin(V)
      +(Poly(U, [ 0.0013381,  0.0001226, -0.0000253]))*cos(V)
      +(Poly(U, [ 0.0000248, -0.0000121]))*sin(2*V)
      -(Poly(U, [ 0.0000305,  0.0000091]))*cos(2*V)
      + 0.0000412*sin(2*zeta)
      + 0.0012415*sin(    Q)
      +(Poly(U, [ 0.0000390,- 0.0000617]))*sin(  zeta)*sin(Q)
      +(Poly(U, [ 0.0000165,- 0.0000204]))*sin(2*zeta)*sin(Q)
      + 0.0026599*cos(  zeta)*sin(  Q)
      - 0.0004687*cos(2*zeta)*sin(  Q)
      - 0.0001870*cos(3*zeta)*sin(  Q)
      - 0.0000821*cos(4*zeta)*sin(  Q)
      - 0.0000377*cos(5*zeta)*sin(  Q)
      + 0.0000497*cos(2* psi)*sin(  Q)
      +(Poly(U, [ 0.0000163,- 0.0000611]))*cos(  Q)
      - 0.0012696*sin(  zeta)*cos(  Q)
      - 0.0004200*sin(2*zeta)*cos(  Q)
      - 0.0001503*sin(3*zeta)*cos(  Q)
      - 0.0000619*sin(4*zeta)*cos(  Q)
      - 0.0000268*sin(5*zeta)*cos(  Q)
      -(Poly(U, [ 0.0000282, 0.0001306]))*cos(  zeta)*cos(  Q)
      +(Poly(U, [-0.0000086, 0.0000230]))*cos(2*zeta)*cos(  Q)
      + 0.0000461*sin(2* psi)*cos(  Q)
      - 0.0000350*sin(2*  Q)
      +(Poly(U, [ 0.0002211, -0.0000286]))*sin( zeta)*sin(2*Q)
      - 0.0002208*sin(2*zeta)*sin(2*Q)
      - 0.0000568*sin(3*zeta)*sin(2*Q)
      - 0.0000346*sin(4*zeta)*sin(2*Q)
      -(Poly(U, [ 0.0002780, 0.0000222]))*cos(  zeta)*sin(2*Q)
      +(Poly(U, [ 0.0002022, 0.0000263]))*cos(2*zeta)*sin(2*Q)
      + 0.0000248*cos(3*zeta)*sin(2*Q)
      + 0.0000242*sin(3* psi)*sin(2*Q)
      + 0.0000467*cos(3* psi)*sin(2*Q)
      - 0.0000490*cos(2*  Q)
      -(Poly(U, [ 0.0002842, 0.0000279]))*sin(  zeta)*cos(2*Q)
      +(Poly(U, [ 0.0000128, 0.0000226]))*sin(2*zeta)*cos(2*Q)
      + 0.0000224*sin(3*zeta)*cos(2*Q)
      +(Poly(U, [-0.0001594, 0.0000282]))*cos(  zeta)*cos(2*Q)
      +(Poly(U, [ 0.0002162,-0.0000207]))*cos(2*zeta)*cos(2*Q)
      + 0.0000561*cos(3*zeta)*cos(2*Q)
      + 0.0000343*cos(4*zeta)*cos(2*Q)
      + 0.0000469*sin(3* psi)*cos(2*Q)
      - 0.0000242*cos(3* psi)*cos(2*Q)
      - 0.0000205*sin(  zeta)*sin(3*Q)
      + 0.0000262*sin(3*zeta)*sin(3*Q)
      + 0.0000208*cos(  zeta)*cos(3*Q)
      - 0.0000271*cos(3*zeta)*cos(3*Q)
      - 0.0000382*cos(3*zeta)*sin(4*Q)
      - 0.0000376*sin(3*zeta)*cos(4*Q);

void twofft(float data1[], float data2[], float fft1[], float fft2[], unsigned long n)
{
  void four1(float data[], unsigned long nn, int isign);
  unsigned long nn3,nn2,jj,j;
  float rep,rem,aip,aim;
  nn3=1+(nn2=2+n+n);
  for (j=1,jj=2;j<=n;j++,jj+=2) { //Pack the two real arrays into one complex
    array. fft1[jj-1]=data1[j];
    fft1[jj]=data2[j];
  }
  four1(fft1,n,1); //Transform the complex array.
  fft2[1]=fft1[2];
  fft1[2]=fft2[2]=0.0;
  for (j=3;j<=n+1;j+=2) {
    rep=0.5*(fft1[j]+fft1[nn2-j]); //Use symmetries to separate the two transforms.
    rem=0.5*(fft1[j]-fft1[nn2-j]);
    aip=0.5*(fft1[j+1]+fft1[nn3-j]);
    aim=0.5*(fft1[j+1]-fft1[nn3-j]);
    fft1[j]=rep; //Ship them out in two complex arrays.
    fft1[j+1]=aim;
    fft1[nn2-j]=rep;
    fft1[nn3-j] = -aim;
    fft2[j]=aip;
    fft2[j+1] = -rem;
    fft2[nn2-j]=aip;
    fft2[nn3-j]=rem;
  }
}

O>Нет. Но как раз у Кнута качество объяснения ни капельки не страдает. Он не упускает ни детали, всегда всё раскладывает по полочкам. Так что о чём вы?

static List<T> QuickSort<T>(List<T> list) where T : IComparable<T>
{
    if (list.Count <= 1)
        return list;
    
    // Принимаем значение элемента из середины массива за значение делящее список
    // на два таких, что в первом находятся элементы большие чем этот, а вдругм
    // меньшие.
    T mid = list[list.Count / 2];
    
    // Отбираем элементы которые...
    
    // Меьше чем mid
    List<T> ltList = list.FindAll(delegate(T elem) { return elem.CompareTo(mid) < 0; });
    // ровны mid
    List<T> eqList = list.FindAll(delegate(T elem) { return elem.CompareTo(mid) == 0; });
    // больше чем mid
    List<T> gtList = list.FindAll(delegate(T elem) { return elem.CompareTo(mid) > 0; });
    
    // сортируем полученные подсписки и конкатенируем их в результирующий список.
    return Concatenate(QuickSort(ltList), eqList, QuickSort(gtList));
}

static List<T> Concatenate<T>(params List<T>[] lists)
{
    List<T> result = new List<T>();
    foreach (List<T> list in lists)
        result.AddRange(list);
    return result;
}

Общий анализ эффективности «быстрой сортировки» достаточно труден.

O>> то, боюсь, его читателям прийдётся верить тому на слово, т.к. без формул, теорем и прочего математического бреда

VD>Боюсь — это может показаться плохим только тем кто слишком любит формализмы.

Вот ответь на вопрос. Может ли широта охвата компенсировать низкое качество объяснения?

A>#define swap(type, a, b) type temp = a; b = b; b = temp;

A>swap(int, a, b)
A>swap(int, a, b) <- очень непонятная ошибка компиляции.
A>

#define Swap(a, b) do { a ^= b; b ^= a; a ^= b; } while(0)

#define Swap(a, b) do { int x = a; a = b; b = x; } while(0)

A>Ага. А сейчас нажимают правую кнопку и выбирают "Go to Definition"

A>А я о высоте, а не о ширине

A>Единственное верное в твоих словах, это уточнение "в том числе". Кнут (и не только он) описывал алгоритм словами и кодом MIX'а. Что касается кода, то к ассемблеру форматирование мало применимо по определению. Так что же тебя не устраивает?

A>>>MSWord у меня замечательно работает Так что аргумент какой-то не такой

A>//--OFF Влад, если уж пишешь мой ник русскими буквами, то запомни, что на конце буква "Ц". адонц.

A>Хм. А извини с какой стати ты мне запрещаешь? Нечем крыть решил заткнуть? или К даже если и так, всё равно какая-то нелепая манера дискутировать.

for(int t=T; i+T<size; i++)
{
    float f1 = 2 * (x[t+T/4] - x[t-T/4]);
    float f2 = -x[t+T/2] + 2*x[t] - x[t-T/2];
    env[t] := sqrt(f1*f1 + f2*f2);
    phi[t] := atan2(f2,f1);
}

for (int frame = period; frame + period < frameCount; frame++)
{
    float filter1 = FirstFilterInHylbertTransform(period, frame);
    float filter2 = SecondFilterInHylbertTransform(period, frame);

    Envelope[frame] = sqrt(sqr(filter1) + sqr(filter2));
    TotalPhase[frame] = atan2(filter2, filter1);
}

...

float SecondFilterInHylbertTransform(int period, int frame)
{
    return -Pinhole[frame + period / 2]
        + 2 * Pinhole[frame] - Pinhole[frame - period / 2];
}

float FirstFilterInHylbertTransform(int period, int frame)
{
    return 2 * (Pinhole[frame + period / 4] - Pinhole[frame - period / 4]);
}

VD>#define Swap(a, b) do { a ^= b; b ^= a; a ^= b; } while(0)
VD>

VD>

VD>#define Swap(a, b) do { int x = a; a = b; b = x; } while(0)
VD>

VD>но первая версия еще и дженерик.

В С активно использовались макросы именно как разновидность inline-процедур. Однако в описании алгоритма макросам (скрывающим функциональность), разумеется, не место.