Código Bowes-Chowdhury-Hockwingham

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 25 de febrero de 2021; las comprobaciones requieren 3 ediciones .

Códigos Bowes-Chowdhury-Hokvingham (códigos BCH) : en la teoría de la codificación, se trata de una amplia clase de códigos cíclicos que se utilizan para proteger la información de errores (consulte Detección y corrección de errores ). Se diferencia por la posibilidad de construir un código con propiedades correctivas predeterminadas, a saber, la distancia mínima del código. Un caso especial de códigos BCH es el código Reed-Solomon .

Descripción formal

Un código BCH es un código cíclico que puede ser dado por un polinomio generador . Para encontrarlo en el caso de un código BCH, es necesario determinar de antemano la longitud del código (no puede ser arbitrario) y la distancia mínima requerida . Puede encontrar un polinomio generador de la siguiente manera. $norte$ $d\leqslant n$

Sea un elemento primitivo del campo (es decir ), sea , un elemento del campo de orden , . Entonces, un polinomio normalizado de grado mínimo sobre un campo cuyas raíces son potencias sucesivas de un elemento para algún número entero (incluyendo 0 y 1) es un polinomio generador de un código BCH sobre un campo con longitud y distancia mínima . $\alfa$ $FG(q^{m})$ $\alpha ^{q^{m}-1}=1,\ \alpha ^{i}\neq 1,\ i<q^{m}-1$ ${\ estilo de visualización \ beta = \ alfa ^ {s}}$ $FG(q^{m})$ $norte$ $s=(q^{m}-1)/n$ $g(x)$ $FG(q)$ ${\ estilo de visualización d-1}$ $\beta ^{l_{0}},\beta ^{l_{0}+1},\ldots,\beta ^{l_{0}+d-2}$ $\beta$ $l_{0}$ $FG(q)$ $norte$ $d_{0}\geqslant d$

Expliquemos por qué el código resultante tendrá exactamente esas características (longitud del código , distancia mínima ). De hecho, como lo muestra Sagalovich [1] , la longitud del código BCH es igual al orden de los elementos si , e igual al orden de los elementos si . Como no nos interesa el caso (tal código no puede corregir errores, solo detectarlos), la longitud del código será igual al orden del elemento , es decir, igual a . La distancia mínima puede ser mayor que cuando las raíces de las funciones mínimas [2] de los elementos son los elementos que expanden la sucesión, es decir, los elementos . $norte$ $d_{0}$ $\beta$ ${\ estilo de visualización d> 2}$ ${\ estilo de visualización \ beta ^ {l_ {0}}}$ ${\ estilo de visualización d = 2}$ ${\ estilo de visualización d = 2}$ $\beta$ $norte$ $d_{0}$ $d$ $\beta ^{l_{0}},\beta ^{l_{0}+1},\ldots,\beta ^{l_{0}+d-2}$ ${\displaystyle \beta ^{l_{0}+d-1},\beta ^{l_{0}+d},\ldots,\beta ^{l_{0}+d_{0}-2))$

El número de símbolos de verificación es igual al grado , el número de símbolos de información , el valor se denomina distancia constructiva del código BCH. Si , entonces el código se llama primitivo , de lo contrario, no primitivo . $r$ $g(x)$ $k=nr$ $d$ $n=q^{m}-1$

Al igual que para el código cíclico, el polinomio de código se puede obtener del polinomio de información de grado máximo , multiplicando y : $c(x)$ $m(x)$ $k-1$ $m(x)$ $g(x)$

{\ estilo de visualización c (x) = m (x) g (x).}

Edificio

Para encontrar el polinomio generador, es necesario realizar varios pasos [3] :

seleccione , es decir, el campo sobre el que se construirá el código; $q$ $FG(q)$
seleccione la longitud del código de la condición , donde son números enteros positivos; $norte$ $n=(q^{m}-1)/s$ ${\ estilo de visualización m, s}$
establecer el valor de la distancia constructiva; $d$
construir clases ciclotómicas de un elemento de campo sobre un campo , donde es un elemento primitivo ; ${\ estilo de visualización \ beta = \ alfa ^ {s}}$ $FG(q^{m})$ $FG(q)$ $\alfa$ $FG(q^{m})$
dado que cada una de estas clases ciclotómicas corresponde a un polinomio irreducible sobre , cuyas raíces son elementos de esta y sólo esta clase, con un grado igual al número de elementos en la clase, entonces elija de tal manera que la longitud total de las clases ciclotómicas sea mínimo; esto se hace para minimizar el número de caracteres de verificación para las características dadas del código ; $FG(q)$ $\beta ^{l_{0}},\beta ^{l_{0}+1},\ldots,\beta ^{l_{0}+d-2}$ $norte$ $d$ $k$
calcular el polinomio generador , donde es el polinomio correspondiente a la -ésima clase ciclotómica; o calcular como el MCM de las funciones mínimas de los elementos de . $g(x)=f_{1}(x)f_{2}(x)\ldots f_{h}(x)$ $arreglar)$ $i$ $g(x)$ $\beta ^{l_{0}},\beta ^{l_{0}+1},\ldots,\beta ^{l_{0}+d-2}$

Ejemplos de código

Código binario primitivo (15, 7, 5)

Sea , la longitud de código requerida y la distancia mínima . Tome — un elemento primitivo del campo , y — cuatro potencias consecutivas del elemento . Pertenecen a dos clases ciclotómicas sobre el campo al que corresponden los polinomios irreducibles y . Entonces el polinomio $q=2$ ${\ estilo de visualización n = 2 ^ {4} -1 = 15}$ $d_{0}\geqslant d=5$ $\alfa$ $novia(16)$ ${\ estilo de visualización \ alfa, \ alfa ^ {2}, \ alfa ^ {3}, \ alfa ^ {4})$ $\alfa$ $FG(2)$ $f_{1}(x)=x^{4}+x+1$ $f_{2}(x)=x^{4}+x^{3}+x^{2}+x+1$

g(x)=f_{1}(x)f_{2}(x)=x^{8}+x^{7}+x^{6}+x^{4}+1

tiene elementos como raíces y es un polinomio generador del código BCH con parámetros . ${\ estilo de visualización \ alfa, \ alfa ^ {2}, \ alfa ^ {3}, \ alfa ^ {4})$ $(15,7,5)$

Código hexadecimal (15, 11, 5) (código Reed-Solomon)

Sea , y sea un elemento primitivo de . Después ${\ estilo de visualización n = q-1 = 15}$ $\alfa$ $novia(16)$

g(x)=(x-\alpha )(x-\alpha ^{2})(x-\alpha ^{3})(x-\alpha ^{4})=x^{4} +\alfa ^{13}x^{3}+\alfa ^{6}x^{2}+\alfa ^{3}x+\alfa ^{10}.

Cada elemento del campo se puede asignar a 4 bits , por lo que una palabra de código equivale a 60 = 15 × 4 bits, por lo que un conjunto de 44 bits se asigna a un conjunto de 60 bits. Podemos decir que dicho código funciona con fragmentos de información. $novia(16)$

Codificación

Para la codificación con códigos BCH, se utilizan los mismos métodos que para la codificación con códigos cíclicos.

Métodos de decodificación

Los códigos BCH son códigos cíclicos, por lo que se les aplican todos los métodos utilizados para decodificar códigos cíclicos. Sin embargo, existen algoritmos mucho mejores desarrollados específicamente para los códigos BCH [4] .

La idea principal en la decodificación de códigos BCH es utilizar los elementos del campo final para numerar las posiciones de la palabra clave (o, de manera equivalente, en el orden de los coeficientes del polinomio asociado). A continuación se muestra una enumeración de este tipo para el vector correspondiente al polinomio . $r=(r_{0},r_{1},\ldots,r_{n-1})$ $r(x)$

valores	$r_{0}$	$r_{1}$	$\ldots$	$r_{{n-1}}$
localizadores de posición	$una$	$\alfa$	$\ldots$	$\alfa ^{{n-1}}$

Sea la palabra recibida asociada al polinomio , donde el polinomio de error se define como: , donde es el número de errores en la palabra recibida. Los conjuntos y se denominan valores de error y localizadores de error, respectivamente, donde , y . ${\ estilo de visualización r (x) = \ nu (x) + e (x)}$ $e(x)=e_{J_{1}}x^{J_{1}}+e_{J_{2}}x^{J_{2}}+\ldots +e_{J_{\nu } }x^{J_{\nu}}$ $\nu \leqslant t_d$ $\{e_{J_{1}},e_{J_{2}},\ldots,e_{J_{\nu }}\}$ ${\displaystyle \{\alpha ^{J_{1)),\alpha ^{J_{2)),\ldots,\alpha ^{J_{\nu ))\))$ $e_{J}\in GF(q)$ $\alpha \in GF(q^{m})$

Los síndromes se definen como los valores del polinomio recibido en los ceros del polinomio de código generador: $r(x)$

S_{1}=r(\alpha ^{b})=e_{J_{1}}\alpha ^{bJ_{1}}+e_{J_{2}}\alpha ^{bJ_{2} }+\ldots +e_{J_{\nu }}\alpha ^{bJ_{\nu )),

S_{2}=r(\alpha ^{b+1})=e_{J_{1}}\alpha ^{(b+1)J_{1}}+e_{J_{2}}\ alfa ^{(b+1)J_{2}}+\ldots +e_{J_{\nu }}\alfa ^{(b+1)J_{\nu )),

\vpuntos

S_{2t_{d}}=r(\alpha ^{b+2t_{d}-1})=e_{J_{1}}\alpha ^{(b+2t_{d}-1)J_ {1}}+e_{J_{2}}\alpha ^{(b+2t_{d}-1)J_{2}}+\ldots +e_{J_{\nu }}\alpha ^{(b+ 2t_ {d}-1)J_{\ nu )),

donde _ ${\ estilo de visualización 2t_ {d} = d-1}$

Para encontrar el conjunto de localizadores de errores, introducimos el polinomio localizador de errores

\sigma (x)=\prod_{l=1}^{\nu }(1+\alpha ^{J_{l}}x)=1+\sigma_{1}x+\sigma_{ 2}x^{2}+\ldots +\sigma _{\nu }x^{\nu },

cuyas raíces son iguales a los recíprocos de los localizadores de errores. Entonces es válida la siguiente relación entre los coeficientes del polinomio localizador de errores y los síndromes [5] :

\sigma_{1}S_{t}+\sigma_{2}S_{t-1}+\ldots +\sigma_{t}S_{1}=-S_{t+1},

\sigma_{1}S_{t+1}+\sigma_{2}S_{t}+\ldots +\sigma_{t}S_{2}=-S_{t+2},

\vpuntos

\sigma_{1}S_{2t-1}+\sigma_{2}S_{2t-2}+\ldots +\sigma_{t}S_{t}=-S_{2t}.

Los siguientes métodos son conocidos para resolver este sistema de ecuaciones con respecto a los coeficientes del polinomio localizador de errores ( sistema clave de ecuaciones ). ${\ estilo de visualización \ sigma _ {i}, \ i = 1,2, \ ldots, \ nu}$

Algoritmo de Berlekamp-Massey (BMA) . En términos del número de operaciones en un campo finito, este algoritmo es altamente eficiente. BMA se usa comúnmente para implementar o modelar mediante programación códigos BCH y códigos Reed-Solomon .
Algoritmo de Euclides (EA) . Debido a la alta regularidad de la estructura de este algoritmo, es ampliamente utilizado para la implementación de hardware de decodificadores BCH y códigos Reed-Solomon .
Solución directa (algoritmo de Peterson-Gorenstein-Zierler, PGC). Históricamente, este es el primer método de decodificación encontrado por Peterson para el caso binario ( ), luego por Gorenstein y Zierler para el caso general. Este algoritmo encuentra los coeficientes del polinomio del localizador de errores mediante la solución directa del sistema de ecuaciones lineales correspondiente. De hecho, dado que la complejidad de este algoritmo crece como el cubo de la distancia mínima , el algoritmo directo solo puede usarse para valores pequeños de , pero es este algoritmo el que mejor aclara la idea algebraica del proceso de decodificación. $q=2$ $d$ $d$

Algoritmo de Berlekamp-Massey

Este algoritmo se ve mejor como un proceso iterativo de construcción de un registro mínimo de retroalimentación (desplazamiento) que genera una secuencia conocida de síndromes . Su objetivo real es construir un polinomio del menor grado que satisfaga la ecuación $S_{1},S_{2},\ldots,S_{2t_{d))$ $\sigma^{{i+1}}(x)$

\sum_{j=0}^{l_{i}+1}S_{kj}\sigma_{j}^{i+1}=0,\quad l_{i}<k<i+ uno .

La solución de esta ecuación es equivalente a la condición

\sigma ^{i+1}(x)=1+\sigma _{1}^{i+1}x+\ldots +\sigma _{l_{i+1}}^{i+1} x^{l_{i+1}}.

El proceso iterativo de construcción de dicho polinomio es el Algoritmo de Berlekamp-Massey .

Algoritmo euclidiano

Este método se basa en el conocido algoritmo de Euclides para encontrar el máximo común divisor de dos números (mcd), solo que en este caso no estamos buscando el mcd de dos números, sino de dos polinomios. Denotemos el polinomio de valores de error como , donde el polinomio sindrómico es igual a . Del sistema de ecuaciones se sigue que . El problema esencialmente se reduce a determinar cuál satisface la última ecuación y al mismo tiempo el grado no es mayor . De hecho, tal solución dará el algoritmo de Euclides extendido aplicado a polinomios y , donde . Si en el enésimo paso el algoritmo euclidiano extendido produce una solución tal que , entonces , y . En este caso, el polinomio encontrado ya no participa en la decodificación (se busca solo como auxiliar). De esta manera, se encontrará el polinomio localizador de errores . $\Lambda =\sigma (x)S(x)$ $S(x)=1+S_{1}x+\ldots +S_{2t_{d}}x^{2t_{d}}$ ${\displaystyle \Lambda (x)=\sigma (x)S(x)\mod x^{2t_{d}+1))$ $\Lambda(x)$ ${\ Displaystyle t_ {d}}$ ${\displaystyle r_{0}(x)=x^{d))$ ${\ Displaystyle r_ {1} (x) = S (x)}$ $d=2t_{d}+1$ $j$ $r_{j}=a_{j}(x)x^{2t_{d}+1}+b_{j}(x)S(x)$ ${\displaystyle \deg[r_{j}(x)]\leqslant t_{d))$ ${\ estilo de visualización \ Lambda (x) = r_ {j} (x)}$ $\sigma _{i}(x)=b_{j}(x)$ $a_{j}(x)$ $\sigma (x)$

Solución directa (algoritmo Peterson-Gorenstein-Zierler, PGC)

Deje que el código BCH sobre el campo de longitud y con una distancia constructiva esté dado por un polinomio generador , que tiene entre sus elementos raíces : un número entero (por ejemplo, 0 o 1). Entonces cada palabra clave tiene la propiedad de que . La palabra recibida se puede escribir como , donde es el polinomio de error. Deje que los errores ocurran en las posiciones ( es el número máximo de errores corregibles), entonces , y son las magnitudes de los errores. $FG(q)$ $norte$ $d$ $g(x)$ $\beta ^{l_{0}},\beta ^{l_{0}+1},\ldots,\beta ^{l_{0}+d-2},\ \beta \in GF(q ^{m}),\\beta^{n}=1,\l_{0}$ $c(\beta ^{l_{0}-1+j})=0,\j=1,2,\ldots,d-1$ $r(x)$ ${\ estilo de visualización r (x) = c (x) + e (x)}$ $ex)$ $u\leqslant t=(d-1)/2$ $i_{1},i_{2},\ldots,i_{u}$ $t$ $e(x)=e_{i_{1}}x^{i_{1}}+e_{i_{2}}x^{i_{2}}+\ldots +e_{i_{u}} x^{i_{u}}$ $e_{i_{1}},e_{i_{2}},\ldots,e_{i_{u}}$

Puedes componer el síndrome th de la palabra aceptada : $j$ $S_j$ $r(x)$

S_{j}=r(\beta ^{l_{0}-1+j})=e(\beta ^{l_{0}-1+j}),\quad j=1,\ldots ,d-1.

La tarea es encontrar el número de errores , sus posiciones y sus significados para los síndromes conocidos . $tu$ $i_{1},i_{2},\ldots,i_{u}$ $e_{i_{1}},e_{i_{2}},\ldots,e_{i_{u}}$ $S_j$

Supongamos para empezar que es exactamente igual a . Escribimos los síndromes en forma de un sistema de ecuaciones no lineales en forma explícita: $tu$ $t$

{\begin{casos}S_{1}=e_{i_{1}}\beta ^{l_{0}i_{1}}+e_{i_{2}}\beta ^{l_{0} i_{2}}+\ldots +e_{i_{t}}\beta ^{l_{0}i_{t}},\\S_{2}=e_{i_{1}}\beta ^{(l_ {0}+1)i_{1}}+e_{i_{2}}\beta ^{(l_{0}+1)i_{2}}+\ldots +e_{i_{t}}\beta ^ {(l_{0}+1)i_{t}},\\\vdots \\S_{d-1}=e_{i_{1}}\beta ^{(l_{0}+d-2)i_ {1}}+e_{i_{2}}\beta ^{(l_{0}+d-2)i_{2}}+\ldots +e_{i_{t}}\beta ^{(l_{0 }+d-2)i_{t}}.\\\end{casos}}

Denote por el localizador del -ésimo error, y por — la magnitud del error, . En este caso, todos son diferentes, ya que el orden del elemento es , y por lo tanto, cuando se conoce , se puede definir como . $X_{k}=\beta^{{i_{k}}}$ $k$ $Y_{k}=e_{{i_{k}}}$ $k=1,\ldots,t$ $X_{k}$ $\beta$ $norte$ $X_{k}$ $yo_{k}$ ${\displaystyle i_{k}=\log_{\beta}X_{k))$

{\begin{casos}S_{1}=Y_{1}X_{1}^{l_{0}}+Y_{2}X_{2}^{l_{0}}+\ldots +Y_ {t}X_{t}^{l_{0}},\\S_{2}=Y_{1}X_{1}^{l_{0}+1}+Y_{2}X_{2}^{ l_{0}+1}+\l puntos +Y_{t}X_{t}^{l_{0}+1},\\\vpuntos \\S_{d-1}=Y_{1}X_{1} ^{l_{0}+d-2}+Y_{2}X_{2}^{l_{0}+d-2}+\ldots +Y_{t}X_{t}^{l_{0}+ d-2}.\end{casos}}

Compongamos un polinomio de localizadores de errores :

\Lambda (x)=(1-xX_{1})(1-xX_{2})\ldots (1-xX_{t})=\Lambda _{t}x^{t}+\Lambda _ {t-1}x^{t-1}+\ldots +\Lambda_{1}x+1.

Las raíces de este polinomio son los elementos inversos a los localizadores de errores. Multiplica ambos lados de este polinomio por . La igualdad resultante será válida para : ${\displaystyle Y_{l}X_{l}^{\vartheta +t))$ $\vartheta =l_{0},l_{0}+1,\ldots,l_{0}+d-1,\l=1,\ldots,t$

\Lambda (x)Y_{l}X_{l}^{\vartheta +t}=\Lambda_{t}x^{t}Y_{l}X_{l}^{\vartheta +t} +\Lambda _{t-1}x^{t-1}Y_{l}X_{l}^{\vartheta +t}+\ldots +\Lambda_{1}xY_{l}X_{l}^ {\vartheta +t}+Y_{l}X_{l}^{\vartheta +t}.

Si sustituimos aquí , entonces obtenemos una igualdad que es válida para todos y para todos : ${\ Displaystyle x=X_{l}^{-1))$ $l\in \{1,2,\ldots,t\}$ ${\displaystyle \vartheta \in \{l_{0},l_{0}+1,\ldots,l_{0}+d-1\))$

0=\Lambda_{t}Y_{l}X_{l}^{\vartheta}+\Lambda_{t-1}Y_{l}X_{l}^{\vartheta +1}+\ ldots +\Lambda _{1}Y_{l}X_{l}^{\vartheta +t-1}+Y_{l}X_{l}^{\vartheta +t}.

Por lo tanto, para cada , puedes escribir tu propia igualdad. Si se suman , entonces obtenemos una igualdad que es válida para cada uno : $yo$ $yo$ ${\displaystyle \vartheta \in \{l_{0},l_{0}+1,\ldots,l_{0}+d-1\))$

0=\Lambda_{t}\sum_{l=1}^{t}Y_{l}X_{l}^{\vartheta}+\Lambda_{t-1}\sum_{l =1}^{t}Y_{l}X_{l}^{\vartheta +1}+\ldots +\Lambda_{1}\sum_{l=1}^{t}Y_{l}X_{ l}^{\vartheta +t-1}+\sum _{l=1}^{t}Y_{l}X_{l}^{\vartheta +t}.

Dado que (es decir, cambia dentro de los mismos límites que antes), el sistema de ecuaciones para síndromes se transforma en un sistema de ecuaciones lineales : $S_{j+p}=\sum_{l=1}^{t}Y_{l}X_{l}^{l_{0}+j+p-1}=\sum_{l= 1}^{t}Y_{l}X_{l}^{\vartheta +p},\ j=1,\ldots,d-1,\ \vartheta =l_{0}+j-1$ $\vartheta$

{\begin{casos}S_{1}\Lambda_{t}+S_{2}\Lambda_{t-1}+\ldots +S_{t}\Lambda_{1}=-S_{ t+1},\\S_{2}\Lambda _{t}+S_{3}\Lambda _{t-1}+\ldots +S_{t+1}\Lambda _{1}=-S_{ t+2},\\\vdots \\S_{t}\Lambda _{t}+S_{t+1}\Lambda _{t-1}+\ldots +S_{2t-1}\Lambda_{ 1}=-S_{2t},\end{casos}}

o, en forma matricial,

S^{(t)} \bar\Lambda^{(t)} = -\bar s^{(t)},

dónde

S^{(t)}={\begin{pmatrix}S_{1}&S_{2}&\ldots &S_{t}\\S_{2}&S_{3}&\ldots &S_{t+1 }\\\vdots &\vdots &\ddots &\vdots \\S_{t}&S_{t+1}&\ldots &S_{2t-1}\end{pmatrix)),\quad {\bar {\Lambda }}^{(t)}={\begin{pmatrix}\Lambda _{t}\\\Lambda _{t-1}\\\vdots \\\Lambda _{1}\end{pmatrix}}, \quad {\bar {s}}^{(t)}={\begin{pmatrix}S_{t+1}\\S_{t+2}\\\vdots \\S_{2t}\end{pmatrix }}.

Si el número de errores es realmente igual a , entonces este sistema tiene solución y se pueden encontrar los valores de los coeficientes . Si el número es , entonces el determinante de la matriz será igual a . Esta es una señal de que el número de errores es menor . Por tanto, es necesario componer un sistema, suponiendo el número de errores igual a , calcular el determinante de la nueva matriz , etc. hasta establecer el verdadero número de errores. $t$ ${\ estilo de visualización \ Lambda _ {1}, \ ldots, \ Lambda _ {t}}$ $tu$ $S^{{(t)}}$ ${\ estilo de visualización 0}$ $t$ ${\ estilo de visualización t-1}$ $S^{{(t-1)}}$

Buscar Chen

Después de resolver el sistema clave de ecuaciones, se obtienen los coeficientes del polinomio localizador de errores. Sus raíces (los elementos inversos a los localizadores de errores) se pueden encontrar simplemente iterando sobre todos los elementos del campo . Para ellos, encuentre elementos que sean inversos a la multiplicación: estos son localizadores de errores . Este proceso es fácil de implementar en hardware. $FG(q^{m})$ $X_{k},\k=1,\ldots,u$

Algoritmo de Forney

Usando los localizadores, puede encontrar las posiciones de error ( ), y los valores de error del sistema para síndromes, al aceptar . Decodificación completada. ${\displaystyle i_{k}=\log_{\beta}X_{k))$ $Y_{k}$ ${\ estilo de visualización t = u}$

Véase también

Notas

↑ Sagalovich, 2007 , pág. 175-176.
↑ Sagalovich, 2007 , pág. 176.
↑ Sagalovich, 2007 , pág. 168.
↑ El arte de la codificación con corrección de errores. Archivado el 1 de abril de 2013 en Wayback Machine , p. 91.
↑ Sagalovich, 2007 , pág. 200.

Literatura

Blahut R. Teoría y práctica de los códigos de control de errores. — M .: Mir , 1986. — 576 p.
Peterson W, Weldon E. Códigos de corrección de errores . - M. : Mir, 1976. - S. 596 .
Sagalovich Yu. L. Introducción a los códigos algebraicos - M. : MIPT , 2007. - 262 p. — ISBN 978-5-7417-0191-1
Morelos-Zaragoza R. El arte de la codificación correctora de errores. Métodos, algoritmos, aplicación. - M. : Technosfera, 2005. - 320 p. — ISBN 5-94836-035-0 .