\documentclass[a4paper,10pt]{article}
\usepackage[utf8]{inputenc} %linux
\usepackage[spanish, activeacute]{babel}
\usepackage{fancyhdr}

\pagestyle{fancy}
%\pdfpagewidth 5.5in
%\pdfpageheight 11in

%\pagestyle{fancy}
%\headheight 35pt

%\rhead{Right top}
%\chead{Middle top}
%\lhead{Left top}
%\rfoot{Right bottom}

%\cfoot{\thepage}
%\lfoot{Left bottom}

%\usepackage[latin1]{inputenc} %windows

%\usepackage[dvips]{epsfig}
%\usepackage{mathrsfs}
%\usepackage{amsmath}
%\usepackage{pst-all}
%\usepackage{amssymb}
%\usepackage{fullpage}
\usepackage{graphicx}

\begin{document}

\fancyhf{}
\fancyhead[L]{\leftmark} %nombre de capítulo
\fancyhead[R]{RMES} % RMES
\fancyfoot[C]{
    Centro de Desarrollo de Gestión Empresarial.\\
    Poniente 1206 – Viña del Mar, Chile.\\
    Fono:(56) (32)688987 – Fax:(56) (32)2684079
    }
\fancyfoot[R]{\thepage} % la pagina

\renewcommand{\footrulewidth}{0.4pt}


\title{\textbf{
Algoritmo Rushdi \\
Software RMES\\
}}
\author{
    Centro de Desarrollo de Gestión Empresarial.\\
    Poniente 1206 – Viña del Mar, Chile.\\
    Fono:(56) (32)688987 – Fax:(56) (32)2684079\\
    empresa@mes.cl
    }
\date{Noviembre, 2009}

\maketitle

\section{Introducción}
Este algoritmo es usado para el cálculo de confiabilidad de sistemas en redundancia o fraccionamiento.
Estos sistemas se conocen como k-out-of-n:G, lo cual significa que el sistema funciona s'i y s'olo s'i
k de sus n componentes est'an operativos. La nomenclatura complementaria,
k-out-of-n:F, se refiere a que el sistema falla s'i y s'olo s'i k de los
n componentes fallan. RMES utiliza la primera definici'on.

\section{El modelo original}
La explicaci'on conceptual del algoritmo se encuentra en el documento
''The k-out-of-n System Model'' en la secci'on ''Symmetric Switching Function
Approach by Rushdi'', paginas 240-244.

A continuación, sólo explicará lo esencial del algoritmo para que
sea de utilidad al momento de implementaci'on y testeo.

La f'ormula original esta propuesta para sistemas de
tipo k-out-of-n:G. Es recursiva y se expresión es la siguiente:

\begin{equation}
R(i,j) = p_j R(i-1,j-1) + q_j R(i,j-1)
\end{equation}

El término $R(i,j)$ se refiere a la confiabilidad del sistema
i-out-of-j:G, es decir, de un sistema que necesita de que al menos
i componentes funcionen para que el sistema no se detenga. Para
efectos pr'acticos, inicialmente ser'ia el sistema en fraccionamiento/redundancia
en estudio, en donde i es la cantidad de equipos que deben
estar en funcionamiento del total j para que el sistema no falle.

$p_j$ se refiere a la confiabilidad del componente $j$ del
sistema.

$q_j$ al complemento de la confiabilidad, $q_j = 1 - p_j$.

La recursi'on debe tener condiciones de borde para su detenci'on.
Estas condiciones son las siguientes:

\begin{equation}
R(0,j) = 1
\end{equation}

\begin{equation}
R(j+1,j) = 0
\end{equation}

\section{Ejemplo}
Se calcular'a la confiabilidad de un sistema 1-out-of-2:G, donde
el primer componente tiene confiabilidad 0.8 y el segundo, 0.9.
Entonces:
\begin{itemize}
  \item $p_1 = 0.8$
  \item $p_2 = 0.9$
  \item $q_1 = 0.2$
  \item $q_2 = 0.1$
\end{itemize}

\begin{eqnarray}
  R(1,2) &=& 0.9 \cdot R(0,1) + 0.1 \cdot R(1,1) \\ \nonumber
  R(0,1) &=& 1\\ \nonumber
\end{eqnarray}

\begin{eqnarray}
  R(1,1) &=& 0.8 \cdot R(0,0) + 0.2 \cdot R(1,0)\\ \nonumber
  R(0,0) &=& 1\\ \nonumber
  R(1,0) &=& 0\\ \nonumber
\end{eqnarray}

Luego
\begin{eqnarray}
  R(1,2) &=& 0.9 + 0.1 \cdot 0.8 \\ \nonumber
  R(1,2) &=& 0.98 \\ \nonumber
\end{eqnarray}

Finalmente, la confiabilidad del sistema 1-out-of-2:G es de 0.98.

\subsection{El algoritmo}
El algoritmo m'as 'optimo para la implementaci'on de este c'alculo
sugiere el uso de una matriz dos dimensional que represente el diagrama
de flujo de la figura \ref{fig:flowchart}.

\begin{figure}[htp]
  \centering
  \includegraphics[width=12cm]{img/rushdiFlowchart.eps}\\
  \caption{Diagrama de flujo obtenido para R(3,7)}
  \label{fig:flowchart}
\end{figure}

La posicion $(i,j)$ representa la confiabilidad
$R(i,j)$. Los nodos negros en la primera fila con $i=0$ son los ''nodos fuente''
con valores iniciales igual a 1, o sea, $R(0, j ) = 1$. Los nodos blancos en la
posici'on $i = j + 1$ son ''nodos fuente'' con valor inicial 0, o sea, 
$R( j + 1, j ) = 0$, $\forall j \geq 0$. Los valores de los otros nodos, por ejemplo,
$(i,j)$, se calculan sumando el producto la entrada superior izquierda por $p_j$ al
producto de la entrada izquierda por $q_j$.

El algoritmo actualmente implementado es el siguiente:

\begin{verbatim}
  double array[][] = new double[k + 1][n + 1];

  for (int j = 0; j < n; j++) {
    array[0][j] = 1.0;
  }

  for (int i = 1; i <= k; i++) {
    for (int j = i; j <= n; j++) {
        double p = ss.getSubsystem(j - 1).R(t);
        array[i][j] = p * array[i - 1][j - 1] + (1 - p) * array[i][j - 1];
    }
  }
  return array[k][n];
\end{verbatim}

Se puede observar que el valor de retorno es el del ultimo nodo de la matriz.
Los valores k y n representan al sistema k-out-of-n:G. La variable $p$ almacena
la confiabilidad del sistema hijo $j-1$. Esta confiabilidad es la calculada en
el tiempo $t$. Tambi'en es posible utilizar la confiabilidad por defecto que
se calcula con un $t$ igual al tiempo de operación del sistema.

\end{document} 
