\documentclass[11pt]{article}
%% Escrevendo em português
\usepackage[brazil]{babel}
\usepackage[latin1]{inputenc}
%% Tamanho da página
\setlength{\textwidth}{17cm}
\setlength{\textheight}{23cm}
%% Parágrafo
\setlength{\parindent}{5mm}
\setlength{\parskip}{1mm}
%% Empurra para cá empurra para lá
\evensidemargin -0.3cm
\oddsidemargin -0.3cm
\topmargin -0.7in
\newcommand{\legal}{${\cal L}g \; $}
\usepackage{boxedminipage}
\newenvironment{smallbox}{\begin{boxedminipage}[t]{\textwidth}\linespread{1.0}\begin{small}}{\end{small}\end{boxedminipage}}
\newenvironment{fnsbox}{\begin{boxedminipage}[t]{0.80\textwidth}\linespread{1.0}\begin{footnotesize}}{\end{footnotesize}\end{boxedminipage}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\hfill {\small Departamento de Ciência da Computação -- IME-USP}


\begin{center}
  \textbf{\large MAC 110 --- Introdução à Computação}
  
  \textsc{BCC --- Primeiro Semestre de 2007}
\end{center}

\noindent
Segundo Exercício-Programa \hfill Prazo de entrega: até {\bf 15 de maio de
2007.} 

\begin{center}
  \underline{Raízes de Equações Quadráticas}
\end{center}

\noindent 
%%%% O primeiro parágrafo a partir daqui.

Escreva um programa em C que calcula as raízes de equações
quadráticas. Seu programa deve ler um real $\varepsilon > 0$ que define a
precisão para cálculo de raízes quadradas, um inteiro $n \geq 
1$ e os coeficientes reais $a$, $b$ e $c$ de $n$ equações do segundo
grau ($ax^{2}+bx+c=0$, com $a \neq 0$). O programa deve calcular as
raízes de cada equação e imprimir os resultados da maneira especificada
abaixo.

\subsection*{Impressão dos resultados}
Para cada equação deve-se imprimir seus coeficientes, o tipo de suas
raízes (reais simples, real dupla ou complexas) e as raízes.
No caso em que as raízes forem complexas, deve-se imprimir a parte
real e a parte imaginária. Exemplo: Para a entrada da
Figura~\ref{exemplo-de-entrada}, a saída do programa deve ser como a 
apresentada na Figura~\ref{exemplo-de-saida}. 

\begin{figure}[htbp]
\begin{center}
\begin{fnsbox}
\begin{verbatim}
1.0e-3
8
1      -2      -3
1      -2      10
1      -2       1
7.18   43.75  -31.21
3     -18      27
0      10      20
1       2       3
1       0      -2
\end{verbatim}
\end{fnsbox}
\end{center}
\caption{Exemplo de entrada para o programa de cálculo de raízes de
         equações quadráticas}
\label{exemplo-de-entrada}
\end{figure}

\begin{figure}[htbp]
\begin{center}
\begin{fnsbox}
\begin{verbatim}
                    Raízes de Equações Quadráticas
-------------------------------------------------------------------------------
     coeficientes       tipo das
   a      b      c      soluções       raiz 1                raiz 2
-------------------------------------------------------------------------------
  1.00  -2.00  -3.00   reais simples   3.0000               -1.0000
  1.00  -2.00  10.00   complexas       1.0000 + i*3.0000     1.0000 - i*3.0000  
  1.00  -2.00   1.00   real dupla      1.0000                1.0000
  7.18  43.75 -31.21   reais simples   0.6451               -6.7384
  3.00 -18.00  27.00   real dupla      3.0000                3.0000
  0.00  10.00  20.00   *** ERRO: equação não é do segundo grau! ***
  1.00   2.00   3.00   complexas      -1.0000 + i*1.4142    -1.0000 - i*1.4142  
  1.00   0.00  -2.00   reais simples   1.4142               -1.4142
\end{verbatim}
\end{fnsbox}
\end{center}
\caption{Saída correspondente à entrada na Figura~\ref{exemplo-de-entrada}}
\label{exemplo-de-saida}
\end{figure}

\subsection*{Cálculo da raiz quadrada de um número real não negativo}
Neste exercício você \underline{não} usará a função \texttt{sqrt(x)}
da biblioteca \texttt{math.h}. Seu programa deve ter
\underline{obrigatoriamente} uma função com protótipo
\begin{verbatim}
        float raiz_quadrada(float x, float epsilon);
\end{verbatim}
que calcula a raiz quadrada de \texttt{x} usando o método de Newton,
descrito a seguir.

Suponha que desejamos extrair a raiz quadrada de um número real $x > 0$.
Escolhe-se como chute inicial para $\sqrt{x}$ o número $r_{0}=x$ e
calcula-se a seguinte seqüência de números:
\[
r_{n+1}=\frac{1}{2}\left(r_{n} + \frac{x}{r_{n}}\right) \makebox[4cm]{$n=0,1,2,\ldots$}
\]
(Ou seja: obtemos
\[
r_{1}=\frac{1}{2}\left(r_{0}+\frac{x}{r_{0}}\right)=
        \frac{1}{2}\left(x+\frac{x}{x}\right)=\frac{x+1}{2},
\]
a partir de $r_{1}$ obtemos $r_{2}$ e assim por diante.)

Esse processo deve ser repetido enquanto $|r_{n+1}-r_{n}| \geq \varepsilon$,
onde $\varepsilon$ é um número positivo dado que representa a precisão do
cálculo da raiz. A aproximação de $\sqrt{x}$ será o primeiro valor
$r_{n+1}$ para o qual $|r_{n+1}-r_{n}| < \varepsilon$.
Utilize como $\varepsilon$ o valor do parâmetro \texttt{epsilon} passado
à função \texttt{raiz\_quadrada}.

\subsection*{Os tipos \texttt{double} e \texttt{long double}}
Vimos em classe apenas um tipo de dados para números ``reais'':
\texttt{float}, que é uma representação em ponto flutuante com
precisão simples. A linguagem C tem outros dois tipos ``reais'' que
podem ser usados quando se precisa de maior precisão: \texttt{double}
(precisão dupla) e \texttt{long double} (precisão extendida). Exemplos
de utilização:

\begin{small}
\begin{verbatim}
    /* declarações de variáveis float, double e long double: */
    float f;
    double d;
    long double ld;

    /* constantes float, double e long double: */
    f = 3.14f;
    d = 3.14;   /* ausência de sufixo "f" ou "L" indica double */
    ld = 3.14L;

    /* leitura de float, double e long double: */
    scanf("%f %lf %Lf", &f, &d, &ld);

    /* impressão de float, double e long double: */
    printf("%f %f %Lf", f, d, ld); 
\end{verbatim}
\end{small}
Note que a leitura e a impressão de \texttt{double}s são feitas com 
especificações de formato diferentes: a leitura é com \texttt{"\%lf"} e
a impressão é com \texttt{"\%f"}. Repare também que a mesma
especificação de formato (\texttt{"\%f"}) é usada para imprimir tanto
\texttt{float}s como \texttt{double}s. (A impressão com \texttt{"\%f"} é,
na verdade, sempre de \texttt{double}s. Quando se imprime um
\texttt{float} com \texttt{"\%f"}, o \texttt{float} é automaticamente
``promovido'' para \texttt{double} antes de ser passado como parâmetro
à função \texttt{printf}.)

\subsection*{Faz diferença usar \texttt{float}, \texttt{double} ou
  \texttt{long double}?} 
Para verificar a influência do tipo ``real'' utilizado, faça os
experimentos descritos abaixo. Use inicialmente uma versão do seu
programa na qual todas as variáveis ``reais'' são do tipo \texttt{float}.
\begin{enumerate}

\item Rode o seu programa com valores cada vez menores do parâmetro
  $\varepsilon$. Começe com $\varepsilon = 10^{-3}$, como no arquivo de
  entrada da figura~\ref{exemplo-de-entrada}, e depois tente usar
  potências de 10 cada vez menores: $\varepsilon = 10^{-3}, 10^{-4},
  10^{-5}, \ldots$ Até que precisão o programa funciona? O que
  acontece quando o programa deixa de funcionar?

\item Crie uma nova versão do seu programa que usa precisão dupla
  (\texttt{double}) para calcular raízes quadradas. Nesta versão do
  programa, a função \texttt{raiz\_quadrada} terá protótipo
  \begin{verbatim}
        float raiz_quadrada(double x, double epsilon);
  \end{verbatim}
  \vspace{-3ex}
  Embora essa versão da função devolva a raiz quadrada como um
  \texttt{float}, internamente ela trabalha só com \texttt{double}s.
  Você pode continuar usando \texttt{float}s no restante do programa,
  exceto quando estiver lendo o valor de $\varepsilon$ da entrada. Esse
  valor deve ser lido como \texttt{double}.

\item Repita o ítem 1 com a segunda versão do programa. Até que
  precisão essa versão do programa funciona? 

\item Crie uma terceira versão do seu programa que usa precisão extendida
  (\texttt{long double}) para calcular raízes quadradas. Nesta versão do
  programa, a função \texttt{raiz\_quadrada} terá protótipo
  \begin{verbatim}
        float raiz_quadrada(long double x, long double epsilon);
  \end{verbatim}
  \vspace{-3ex}
  Embora essa versão da função devolva a raiz quadrada como um 
  \texttt{float}, internamente ela trabalha só com \texttt{long double}s. 
  Você pode continuar usando \texttt{float}s no restante do programa,
  exceto quando estiver lendo o valor de $\varepsilon$ da entrada. Esse
  valor deve ser lido como \texttt{long double}. 

\item Repita o ítem 1 com a terceira versão do programa e descubra
  até que precisão essa versão do programa funciona.
\end{enumerate}

\subsection*{Que versão do programa deve ser entregue?}

Entregue apenas a versão que usa precisão dupla (\texttt{double}) para
calcular raízes quadradas, mas coloque num comentário no início do
programa, logo após o cabeçalho com seu nome e número USP, suas
respostas para as seguintes questões:
\begin{enumerate}
\item[(a)] Até que precisão funcionou o programa só com \texttt{float}s?
\item[(b)] Até que precisão funcionou o programa que usa precisão
  dupla para calcular a raízes quadradas?
\item[(c)] Até que precisão funcionou o programa que usa precisão
  extendida para calcular a raízes quadradas?
\item[(d)] Para cada uma das três versões do programa, explique também
  o que acontece quando a precisão é excessiva e o programa deixa de
  funcionar. 
\end{enumerate}

\newpage
%\bigskip
\begin{center}
  \underline{\Large \sc Observações Importantes}
\end{center}
\footnotesize
\begin{itemize}

\item [1)] Todos os exercícios-programa devem ter um cabeçalho como o
  seguinte: 

\begin{verbatim}
           /**********************************************************/
           /* Aluno: Fulano de Tal                                   */
           /* Número USP: 12345678                                   */
           /* Exercicio-Programa 2 -- Raízes de Equações Quadráticas */
           /* MAC110 (BCC) -- 2007 -- Professor: Reverbel            */
           /* Compilador: ... (DevC++ ou gcc) versão ...             */
           /**********************************************************/
\end{verbatim}

\item [2)] O exercício-programa é \underline{estritamente individual}. Exercícios
  copiados (com ou sem eventuais disfarces) receberão nota ZERO.


\item [3)] \underline{Exercícios atrasados não serão aceitos}.

\item [4)] Exerc\'\i cios com erros de sintaxe (ou seja, erros de compilação)
 receberão nota ZERO. 
%Seu programa deve ser compilável sem erros ou
% \emph{warnings} pelo \texttt{gcc}, com as opções ``\texttt{-Wall -ansi
% -pedantic -O2}''.

\item [5)] É \underline{muito importante} que seu programa tenha comentários e
   esteja bem indentado, ou seja,
  digitado de maneira a ressaltar a estrutura de subordinação dos comandos
  do programa (conforme visto em aula).  A avaliação dos
  exercícios-programa levará isto em conta. 

% \item [5)] Voc\^e deve entregar num envelope (preferencialmente  de  pl\'astico
% transparente):
% \begin{itemize}  
% \item um disquete (que lhe ser\'a devolvido) com os arquivos que
%   correspondem aos programas (isto é, arquivos .c).  Não se esqueça de
%   colocar uma etiqueta no disquete com o seu nome completo, turma e
%   professor.

% \item listagens dos programas.
 
% \item a saída impressa correspondente à execução de cada um dos
%  programas. Esta deve mostrar todos os dados de entrada, da forma mais
%  clara e organizada possível.
% \end{itemize}

\item [6)]
Cada programa deve ter sido executado tantas vezes quantas forem
necessárias para testar os vários casos possíveis para as entradas. 
% A escolha desses dados também influirá na sua nota. 
  
% \item [7)] Guarde com voc\^e at\'e o final do semestre, em seus
%   disquetes, os arquivos de seus programas, pois eles podem ser
%   solicitados pelo professor caso surja alguma d\'uvida. Guarde
%   tamb\'em as listagens que lhe ser\~ao devolvidas, nas quais est\'a
%   marcada a nota que voc\^e recebeu.

%\item [8)] Entregue o seu programa na urna (caixa de madeira) que fica
%  em frente à sala 256 do Bloco A do IME-USP.

\item [7)] Você entregará seu exercício-programa através do sistema
  Paca/Moodle (\texttt{http://paca.ime.usp.br}). Para isto você precisa
  estar cadastrado nesse sistema (use o seu número USP para se
  cadastrar) e registrado no Paca como aluno da disciplina
  \texttt{MAC110-BCC} (uma vez cadastrado no Paca, basta entrar na área
  da disciplina \texttt{MAC110-BCC} que o sistema perguntará a você se
  deseja se registrar como aluno da disciplina).

\item [8)] Entregue apenas o programa fonte em C, num arquivo com nome
  \texttt{ep2-}$<$\emph{seu-número-USP}$>$\texttt{.c}. (Exemplo: se seu
  número USP for 12345678, você deverá entregar um arquivo
  \texttt{ep2-12345678.c}.) 

\item [9)] Enquanto o prazo de entrega não expirar, você poderá entregar
  várias versões do mesmo exercício-programa. Apenas a última versão
  entregue será guardada pelo sistema. Encerrado o prazo, o sistema não
  aceitará mais a entrega de exercícios-programa. Não deixe para entregar seu
  exercício na última hora!

\item [10)] Guarde uma cópia do seu exercício-programa pelo menos até o
  final do semestre.

\end{itemize}

\large

\begin{center}
\textbf{Bom trabalho!}
\end{center}

\end{document}
