\hypertarget{PARITY_8h}{
\section{PARITY.h File Reference}
\label{PARITY_8h}\index{PARITY.h@{PARITY.h}}
}
Priority calculation, callable interface. 



This graph shows which files directly or indirectly include this file:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=186pt]{PARITY_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Defines}
\begin{CompactItemize}
\item 
\#define \hyperlink{PARITY_8h_a0}{PARITY\_\-K\_\-EVEN}~0x6996
\begin{CompactList}\small\item\em A vector of bits whose bit number (counting from least significant bit = 0) gives the even parity of a nibble of that bit number. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a1}{
\#define \hyperlink{PARITY_8h_a1}{PARITY\_\-4}(\_\-nibble)~((PARITY\_\-K\_\-EVEN $>$$>$ ((\_\-nibble) \& 0xf)) \& 1)}
\label{PARITY_8h_a1}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-nibble\/} is {\em even\/}, 1 if the parity is {\em odd\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a2}{
\#define \hyperlink{PARITY_8h_a2}{PARITY\_\-8}(\_\-byte)~PARITY\_\-4 ( ((\_\-byte ) $>$$>$  4) $^\wedge$ (\_\-byte ))}
\label{PARITY_8h_a2}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-byte\/} is {\em even\/}, 1 if the parity is {\em odd\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a3}{
\#define \hyperlink{PARITY_8h_a3}{PARITY\_\-16}(\_\-hword)~PARITY\_\-8 ( ((\_\-hword) $>$$>$  8) $^\wedge$ (\_\-hword))}
\label{PARITY_8h_a3}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-hword\/} is {\em even\/}, 1 if the parity is {\em odd\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a4}{
\#define \hyperlink{PARITY_8h_a4}{PARITY\_\-32}(\_\-word)~PARITY\_\-16( ((\_\-word ) $>$$>$ 16) $^\wedge$ (\_\-word ))}
\label{PARITY_8h_a4}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-word\/} is {\em even\/}, 1 if the parity is {\em odd\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a5}{
\#define \hyperlink{PARITY_8h_a5}{PARITY\_\-64}(\_\-ll)~PARITY\_\-32( ((\_\-ll   ) $>$$>$ 32) $^\wedge$ (\_\-ll   ))}
\label{PARITY_8h_a5}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-ll\/} is {\em even\/}, 1 if the parity is {\em odd\/}. \item\end{CompactList}\item 
\#define \hyperlink{PARITY_8h_a6}{PARITY\_\-K\_\-ODD}~0x9669
\begin{CompactList}\small\item\em A vector of bits whose bit number (counting from least significant bit = 0) gives the odd parity of a nibble of that bit number. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a7}{
\#define \hyperlink{PARITY_8h_a7}{PARITY\_\-ODD4}(\_\-nibble)~((PARITY\_\-K\_\-ODD $>$$>$ ((\_\-nibble) \& 0xf)) \& 1)}
\label{PARITY_8h_a7}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-nibble\/} is {\em odd\/}, 1 if the parity is {\em even\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a8}{
\#define \hyperlink{PARITY_8h_a8}{PARITY\_\-ODD8}(\_\-byte)~PARITY\_\-ODD4 ( ((\_\-byte ) $>$$>$  4) $^\wedge$ (\_\-byte ))}
\label{PARITY_8h_a8}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-byte\/} is {\em odd\/}, 1 if the parity is {\em even\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a9}{
\#define \hyperlink{PARITY_8h_a9}{PARITY\_\-ODD16}(\_\-hword)~PARITY\_\-ODD8 ( ((\_\-hword) $>$$>$  8) $^\wedge$ (\_\-hword))}
\label{PARITY_8h_a9}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-hword\/} is {\em odd\/}, 1 if the parity is {\em even\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a10}{
\#define \hyperlink{PARITY_8h_a10}{PARITY\_\-ODD32}(\_\-word)~PARITY\_\-ODD16( ((\_\-word ) $>$$>$ 16) $^\wedge$ (\_\-word ))}
\label{PARITY_8h_a10}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-word\/} is {\em odd\/}, 1 if the parity is {\em even\/}. \item\end{CompactList}\item 
\hypertarget{PARITY_8h_a11}{
\#define \hyperlink{PARITY_8h_a11}{PARITY\_\-ODD64}(\_\-ll)~PARITY\_\-ODD32( ((\_\-ll   ) $>$$>$ 32) $^\wedge$ (\_\-ll   ))}
\label{PARITY_8h_a11}

\begin{CompactList}\small\item\em Returns 0 if the parity of {\em \_\-ll\/} is {\em odd\/}, 1 if the parity is {\em even\/}. \item\end{CompactList}\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item 
int \hyperlink{PARITY_8h_a12}{PARITY\_\-calc8} (unsigned char byte)
\begin{CompactList}\small\item\em Calculates the parity over the 8 bits in the specified byte. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a13}{PARITY\_\-calc16} (unsigned short int hword)
\begin{CompactList}\small\item\em Calculates the parity over the 16 bits in the specified half word. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a14}{PARITY\_\-calc32} (unsigned int word)
\begin{CompactList}\small\item\em Calculates the parity over the 32 bits in the specified word. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a15}{PARITY\_\-calc64} (unsigned long long int ll)
\begin{CompactList}\small\item\em Calculates the parity over the 64 bits in the specified long long. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a16}{PARITY\_\-calc8N} (const unsigned char $\ast$bytes, int nbytes)
\begin{CompactList}\small\item\em Calculates the parity over all the bits in the specified array of bytes. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a17}{PARITY\_\-calc16N} (const unsigned short int $\ast$hwords, int nhwords)
\begin{CompactList}\small\item\em Calculates the parity over all the bits in the specified array of half words (16-bit integers). \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a18}{PARITY\_\-calc32N} (const unsigned int $\ast$words, int nwords)
\begin{CompactList}\small\item\em Calculates the parity over all the bits in the specified array of words (32-bit integers). \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a19}{PARITY\_\-calc64N} (const unsigned long long int $\ast$lls, int nlls)
\begin{CompactList}\small\item\em Calculates the parity over all the bits in the specified array of long longs (64-bit integers). \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a20}{PARITY\_\-calc\-Odd8} (unsigned char byte)
\begin{CompactList}\small\item\em Calculates the odd parity over the 8 bits in the specified byte. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a21}{PARITY\_\-calc\-Odd16} (unsigned short int hword)
\begin{CompactList}\small\item\em Calculates the odd parity over the 16 bits in the specified half word. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a22}{PARITY\_\-calc\-Odd32} (unsigned int word)
\begin{CompactList}\small\item\em Calculates the odd parity over the 32 bits in the specified word. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a23}{PARITY\_\-calc\-Odd64} (unsigned long long int ll)
\begin{CompactList}\small\item\em Calculates the odd parity over the 64 bits in the specified long long. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a24}{PARITY\_\-calc\-Odd8N} (const unsigned char $\ast$bytes, int nbytes)
\begin{CompactList}\small\item\em Calculates the odd parity over all the bits in the specified array of bytes. \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a25}{PARITY\_\-calc\-Odd16N} (const unsigned short int $\ast$hwords, int nhwords)
\begin{CompactList}\small\item\em Calculates the odd parity over all the bits in the specified array of half words (16-bit integers). \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a26}{PARITY\_\-calc\-Odd32N} (const unsigned int $\ast$words, int nwords)
\begin{CompactList}\small\item\em Calculates the odd parity over all the bits in the specified array of words (32-bit integers). \item\end{CompactList}\item 
int \hyperlink{PARITY_8h_a27}{PARITY\_\-calc\-Odd64N} (const unsigned long long int $\ast$lls, int nlls)
\begin{CompactList}\small\item\em Calculates the odd parity over all the bits in the specified array of long longs (64-bit integers). \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Priority calculation, callable interface. 

\begin{Desc}
\item[Author:]JJRussell - \href{mailto:russell@slac.stanford.edu}{\tt russell@slac.stanford.edu}\end{Desc}


\footnotesize\begin{verbatim}    CVS $Id: PARITY.h,v 1.1.1.1 2006/02/10 21:45:35 saxton Exp $
\end{verbatim}
\normalsize


\begin{Desc}
\item[]For full documentation and explanation of the algorithms, see the inline versions, documented in PARITY.ih. For the parity calculations\end{Desc}
\begin{itemize}
\item Over immediate values (a single byte, short int, int, long long), one should the macro versions.\item Over variables values (a single byte,short int, int, long long), one should use the inline versions for the type safety they provide.\item Over arrays, one has a choice between the inlines (possibly faster) and the traditional call interface (less code)\end{itemize}


\subsection{Define Documentation}
\hypertarget{PARITY_8h_a0}{
\index{PARITY.h@{PARITY.h}!PARITY_K_EVEN@{PARITY\_\-K\_\-EVEN}}
\index{PARITY_K_EVEN@{PARITY\_\-K\_\-EVEN}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-K\_\-EVEN]{\setlength{\rightskip}{0pt plus 5cm}\#define PARITY\_\-K\_\-EVEN~0x6996}}
\label{PARITY_8h_a0}


A vector of bits whose bit number (counting from least significant bit = 0) gives the even parity of a nibble of that bit number. 

\begin{Desc}
\item[]This is a bit vector whose bit number gives the even parity of that bit number. The array is {\em indexed\/} by left shifting by the bit number. This array is used to return a 0 if the parity is EVEN and a 1 if the parity is ODD.\end{Desc}
The following table maps a number {\em idx\/} into an even parity. The bottom line is the hex number representing the parity bit array.



\footnotesize\begin{verbatim}       Idx  Parity    Index  Parity   Index Parity    Index Parity
         C       0        8       1       4      1        0      0
         D       1        9       0       5      0        1      1
         E       1        A       0       6      0        2      1
         F       0        B       1       7      1        3      0
      0x         6                9              9               6
  \end{verbatim}
\normalsize
\hypertarget{PARITY_8h_a6}{
\index{PARITY.h@{PARITY.h}!PARITY_K_ODD@{PARITY\_\-K\_\-ODD}}
\index{PARITY_K_ODD@{PARITY\_\-K\_\-ODD}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-K\_\-ODD]{\setlength{\rightskip}{0pt plus 5cm}\#define PARITY\_\-K\_\-ODD~0x9669}}
\label{PARITY_8h_a6}


A vector of bits whose bit number (counting from least significant bit = 0) gives the odd parity of a nibble of that bit number. 

\begin{Desc}
\item[]This is a bit vector whose bit number gives the odd parity of that bit number, The array is {\em indexed\/} by left shifting by the bit number. This array is used to return a 0 if the parity is ODD and a 1 if the parity is EVEN.\end{Desc}
The following table maps a number {\em idx\/} into an even parity. The bottom line is the hex number representing the parity bit array.



\footnotesize\begin{verbatim}       Idx  Parity    Index  Parity   Index Parity    Index Parity
         C       1        8       0       4      0        0      1
         D       0        9       1       5      1        1      0
         E       0        A       1       6      1        2      0
         F       1        B       0       7      0        3      1
      0x         9                6              6               9
  \end{verbatim}
\normalsize


\subsection{Function Documentation}
\hypertarget{PARITY_8h_a13}{
\index{PARITY.h@{PARITY.h}!PARITY_calc16@{PARITY\_\-calc16}}
\index{PARITY_calc16@{PARITY\_\-calc16}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc16]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc16 (unsigned short int {\em hword})}}
\label{PARITY_8h_a13}


Calculates the parity over the 16 bits in the specified half word. 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over the 16 bits the specified half word.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em hword}]The half word (short int) to calculate the parity of.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a17}{
\index{PARITY.h@{PARITY.h}!PARITY_calc16N@{PARITY\_\-calc16N}}
\index{PARITY_calc16N@{PARITY\_\-calc16N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc16N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc16N (const unsigned short int $\ast$ {\em hwords}, int {\em nhwords})}}
\label{PARITY_8h_a17}


Calculates the parity over all the bits in the specified array of half words (16-bit integers). 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over all the bits in the specified array of half words (16-bit integers). If a length of 0 is specified, 0 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em hwords}]The array of half words (16-bit integers) to calculate the parity over. \item[{\em nhwords}]The number of half words (16-bit integers) in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a14}{
\index{PARITY.h@{PARITY.h}!PARITY_calc32@{PARITY\_\-calc32}}
\index{PARITY_calc32@{PARITY\_\-calc32}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc32]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc32 (unsigned int {\em word})}}
\label{PARITY_8h_a14}


Calculates the parity over the 32 bits in the specified word. 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over the 32 bits the specified word.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em word}]The word to calculate the parity over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a18}{
\index{PARITY.h@{PARITY.h}!PARITY_calc32N@{PARITY\_\-calc32N}}
\index{PARITY_calc32N@{PARITY\_\-calc32N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc32N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc32N (const unsigned int $\ast$ {\em words}, int {\em nwords})}}
\label{PARITY_8h_a18}


Calculates the parity over all the bits in the specified array of words (32-bit integers). 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, of the specified array of words. If a length of 0 is specified, 0 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em words}]The array of words (ints) to calculate the parity over. \item[{\em nwords}]The number of words (ints) in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a15}{
\index{PARITY.h@{PARITY.h}!PARITY_calc64@{PARITY\_\-calc64}}
\index{PARITY_calc64@{PARITY\_\-calc64}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc64]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc64 (unsigned long long int {\em ll})}}
\label{PARITY_8h_a15}


Calculates the parity over the 64 bits in the specified long long. 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over the 64 bits the specified long long.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ll}]The long long word to calculate the parity over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a19}{
\index{PARITY.h@{PARITY.h}!PARITY_calc64N@{PARITY\_\-calc64N}}
\index{PARITY_calc64N@{PARITY\_\-calc64N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc64N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc64N (const unsigned long long int $\ast$ {\em lls}, int {\em nlls})}}
\label{PARITY_8h_a19}


Calculates the parity over all the bits in the specified array of long longs (64-bit integers). 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, of the specified array of words. If a length of 0 is specified, 0 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em lls}]The array of long longs to calculate the parity over. \item[{\em nlls}]The number of long longs in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a12}{
\index{PARITY.h@{PARITY.h}!PARITY_calc8@{PARITY\_\-calc8}}
\index{PARITY_calc8@{PARITY\_\-calc8}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc8]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc8 (unsigned char {\em byte})}}
\label{PARITY_8h_a12}


Calculates the parity over the 8 bits in the specified byte. 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over the 8 bits in the specified byte.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em byte}]The byte to calculate the parity over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a16}{
\index{PARITY.h@{PARITY.h}!PARITY_calc8N@{PARITY\_\-calc8N}}
\index{PARITY_calc8N@{PARITY\_\-calc8N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calc8N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc8N (const unsigned char $\ast$ {\em bytes}, int {\em nbytes})}}
\label{PARITY_8h_a16}


Calculates the parity over all the bits in the specified array of bytes. 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, over the specified array of bytes. If a length of 0 is specified, 0 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bytes}]The array of bytes to calculate the parity over. \item[{\em nbytes}]The number of bytes in array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a21}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd16@{PARITY\_\-calcOdd16}}
\index{PARITY_calcOdd16@{PARITY\_\-calcOdd16}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd16]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd16 (unsigned short int {\em hword})}}
\label{PARITY_8h_a21}


Calculates the odd parity over the 16 bits in the specified half word. 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over the 16 bits the specified half word.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em hword}]The half word (short int) to calculate the odd parity of.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a25}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd16N@{PARITY\_\-calcOdd16N}}
\index{PARITY_calcOdd16N@{PARITY\_\-calcOdd16N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd16N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd16N (const unsigned short int $\ast$ {\em hwords}, int {\em nhwords})}}
\label{PARITY_8h_a25}


Calculates the odd parity over all the bits in the specified array of half words (16-bit integers). 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over all the bits in the specified array of half words (16-bit integers). If a length of 0 is specified, 1 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em hwords}]The array of half words (16-bit integers) to calculate the odd parity over. \item[{\em nhwords}]The number of half words (16-bit integers) in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a22}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd32@{PARITY\_\-calcOdd32}}
\index{PARITY_calcOdd32@{PARITY\_\-calcOdd32}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd32]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd32 (unsigned int {\em word})}}
\label{PARITY_8h_a22}


Calculates the odd parity over the 32 bits in the specified word. 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over the 32 bits the specified word.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em word}]The word to calculate the odd parity over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a26}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd32N@{PARITY\_\-calcOdd32N}}
\index{PARITY_calcOdd32N@{PARITY\_\-calcOdd32N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd32N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd32N (const unsigned int $\ast$ {\em words}, int {\em nwords})}}
\label{PARITY_8h_a26}


Calculates the odd parity over all the bits in the specified array of words (32-bit integers). 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, of the specified array of words. If a length of 0 is specified, 1 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em words}]The array of words (ints) to calculate the odd parity over. \item[{\em nwords}]The number of words (ints) in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a23}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd64@{PARITY\_\-calcOdd64}}
\index{PARITY_calcOdd64@{PARITY\_\-calcOdd64}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd64]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd64 (unsigned long long int {\em ll})}}
\label{PARITY_8h_a23}


Calculates the odd parity over the 64 bits in the specified long long. 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over the 64 bits the specified long long.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ll}]The long long word to calculate the parity odd over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a27}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd64N@{PARITY\_\-calcOdd64N}}
\index{PARITY_calcOdd64N@{PARITY\_\-calcOdd64N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd64N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd64N (const unsigned long long int $\ast$ {\em lls}, int {\em nlls})}}
\label{PARITY_8h_a27}


Calculates the odd parity over all the bits in the specified array of long longs (64-bit integers). 

\begin{Desc}
\item[Returns:]The parity, either 0 or 1, of the specified array of words. If a length of 0 is specified, 1 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em lls}]The array of long longs to calculate the parity over. \item[{\em nlls}]The number of long longs in the array.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a20}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd8@{PARITY\_\-calcOdd8}}
\index{PARITY_calcOdd8@{PARITY\_\-calcOdd8}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd8]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd8 (unsigned char {\em byte})}}
\label{PARITY_8h_a20}


Calculates the odd parity over the 8 bits in the specified byte. 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over the 8 bits in the specified byte.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em byte}]The byte to calculate the odd parity over.\end{description}
\end{Desc}
\hypertarget{PARITY_8h_a24}{
\index{PARITY.h@{PARITY.h}!PARITY_calcOdd8N@{PARITY\_\-calcOdd8N}}
\index{PARITY_calcOdd8N@{PARITY\_\-calcOdd8N}!PARITY.h@{PARITY.h}}
\subsubsection[PARITY\_\-calcOdd8N]{\setlength{\rightskip}{0pt plus 5cm}int PARITY\_\-calc\-Odd8N (const unsigned char $\ast$ {\em bytes}, int {\em nbytes})}}
\label{PARITY_8h_a24}


Calculates the odd parity over all the bits in the specified array of bytes. 

\begin{Desc}
\item[Returns:]The odd parity, either 0 or 1, over the specified array of bytes. If a length of 0 is specified, 1 is returned.\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bytes}]The array of bytes to calculate the odd parity over. \item[{\em nbytes}]The number of bytes in array.\end{description}
\end{Desc}
