Debian 6.0.6 - GRUB não reconhece o sistema que já estava instalado

Ao instalar o Debian GNU/Linux 6.0.6 Squeeze i386 paralelamente com outro sistema operacional que já esteja instalado no PC, o GRUB (programa que é executado ao ligar o PC para escolher em qual sistema operacional irá "entrar") não reconheceu o sistema que já estava instalado.

Para que o GRUB reconheça outros sistemas que já estavam instalados antes de instalar o Debian é necessário atualizar o GRUB, uma das formas é a seguinte:

Abrir o terminal. Pode ser aberto com o atalho utilizando as teclas Ctrl + Alt + T.

Entre como superusuário, bastando digitar "su", em seguida digite a senha, e estará como root (#):

~:$ su
Senha:
#

Basta digitar: "update-grub":

# update-grub

Ao digitar esse último comando, irá aparecer no terminal os sistemas que ficarão como opção para escolha ao iniciar o PC. Reinicie o PC e verifique se o(s) sistema(s) que não foi(ram) reconhecido(s) está(ão) disponível(is) para inicialização no GRUB.

Solver - resolvendo um problema e interpretando seus relatórios

Resolver o seguinte problema:

Variáveis: X1 = Cadeira e X2 = Mesa

Maximizar Lucro = 4 * X1 + 1 * X2

S.A: Madeira) 2 * X1 + 3 * X2 >= 12

Metal) 2 * X1 + 1 * X2 >= 8

Primeiramente, deve-se preencher as células da planilha:

Como exemplo:

A5:A6 [ Variáveis ]

A9:A10 [ Restrições]

B3 [ Lucro ]

B5 [ Cadeira ]

B6 [ Mesa ]

B9 [ Madeira]

B10 [ Metal ]

C3 [ =4*C5+1*C6 ]

C5 [ 1 ]

C6 [ 1 ]

C9 [ =2*C5+3*C6 ]

C10 [ =2*C5+1*C6]

D8 [ Limites ]

D9 [ 12 ]

D10 [ 8 ]

Clicar em Dados / Solver.

Caso o solver não esteja “ativado”, deverá se ativado da seguinte forma:

• clicar no símbolo (círculo) no canto superior esquerdo;
• clicar em “Opções”;
• clicar em “Suplementos”;
• clicar em “Solver” (selecionar);
• clicar em “ir...”
• clicar em “solver” (selecionar);
• clicar em “Ok”;
• se preguntar se “Deseja instalá-lo agora?” Clicar em “Sim”.

Após clicar em “Dados / Solver” irá abrir a “janela do Solver”.

Entrar com os seguinte dados:

• Definir célula de destino: $C$3
• Igual a: Máx
• Células variáveis: $C$5:$C$6
• Submeter às restrições: Adicionar: $C$10 <= $D$10 Adicionar: $C$9 <= $D$9
• Clicar em opções, marcar a opção: Presumir não negativos. Com isso X1 e X2 >= 0
• Clicar em Ok
• Clicar em Resolver
• Relatórios, marcar: Resposta, Sensibilidade e Limites

Interpretação dos relatórios para o exemplo dado:

Relatório de resposta:

• célula de destino: valor do lucro (valor final). Lucro = 16
• células ajustáveis: valor de cadeira e mesa a ser produzido (valor final). Cadeira = 4; Mesa = 0
• restrições status: sem agrupar, a solução obtida não coincide com o valor limite da restrição; agrupar, a solução obtida coincide com o valor limite da restrição. Madeira = sem agrupar; Metal = Agrupar;
• Restrição transigência: diferença entre o valor limite e o valor obtido pela restrição. Madeira = 12-8=4; Metal = 8-8=0;

Relatório de sensibilidade:

• Reduzido gradiente: mede o crescimento do objetivo por unidade na célula ajustável, ou seja, quanto varia o lucro se passar a produzir mais um produto. Se passar a produzir mais uma mesa o lucro passa a ser 15. Se passar a produzir mais duas mesas o lucro para a ser 14; Cadeira = 0; Mesa = -1;
• Lagrange Multiplicador: Alteração da F.O. para um aumento unitário nos limites das restrições. Se for zero, significa uma restrição cuja solução não atingiu o limite especificado; Madeira = 0; Metal = 2

Relatório de limites

• Limite inferior: menor valor que a variável pode assumir, em função das restrições e do resultado. Cadeira = 0; Mesa = 0;
• Limite superior: maior valor que a variável pode assumir, em função das restrições e do resultado; Cadeira = 4; Mesa = 0;
• Destino resultado: o valor de F.O. caso esteja nesse limite (inferior ou superior).
• Obs.: nesse exemplo, como não se produz mesa, o destino será sempre 16, para a mesa, pois a mesma não é produzida. Caso não se produza cadeira, o destino resultado será 0, caso produza o máximo de cadeira, o destino resultado será 16.

Lazarus - Componente GroupBox

Componente GroupBox

Monte a estrutura abaixo com 2 componetes GroupBox. Um com a propriedade Caption sendo Sexo e o outro sendo Idade. Em seguida adicione dois RadioButton em cada Group Box. Verifique a "hierarquia" na janela ObjectInspector.

Adicione os outros componentes, altere a propriedade Caption e Name de cada componente, conforme abaixo:

O programa deverá mostrar as seguintes informações através do ShowMessage, conforme as opções que forem selecionadas:
- Feminino e Maior 18 anos = “Mulher liberada”
- Feminino e Menor 18 anos = “Mulher não liberada”
- Masculino e Maior 18 anos = “Homem liberado”
- Masculino e Menor 18 anos = “Homem não liberado”
Caso não se selecione o sexo, deverá aparecer a informação: "Favor informar o sexo".
Caso não se selecione a idade, deverá aparecer a informação: "Favor informar a idade".

Programe o botão Calcular com o seguinte código:


------------------------------------------------------------------------------------
procedure TFrmControle.BtnCalcularClick(Sender: TObject);
begin
  if (RdBtnMaior.Checked)
     then if (RdBtnFeminino.Checked)
          then showmessage('Mulher liberada.')
          else if (RdBtnMasculino.Checked) then showmessage('Homem liberado.');
  if (RdBtnMenor.Checked)
     then if (RdBtnFeminino.Checked)
          then showmessage('Mulher não liberada.')
          else if (RdBtnMasculino.Checked) then showmessage('Homem não liberado.');
  if (RdBtnFeminino.Checked = False) and (RdBtnMasculino.Checked = False)
     then showmessage('Favor escolher uma opção de sexo.');
  if (RdBtnMaior.Checked = False) and (RdBtnMenor.Checked = False)
     then showmessage('Favor escolher uma opção de idade.');
end;  
------------------------------------------------------------------------------------


Programe o botão Limpar com o seguinte código:
------------------------------------------------------------------------------------
 procedure TFrmControle.BtnLimparClick(Sender: TObject);
begin
     RdBtnMaior.Checked := False;
     RdBtnMenor.Checked := False;
     RdBtnFeminino.Checked := False;
     RdBtnMasculino.Checked := False;
end;
------------------------------------------------------------------------------------

 Programe o botão Sair com o seguinte código:
------------------------------------------------------------------------------------
 procedure TFrmControle.BtnSairClick(Sender: TObject);
begin
  Close;
end; 
------------------------------------------------------------------------------------

Lazarus - Componente RadioButton

Monte um formulário com 3 label, 3 edit, 3 botton e 4 radiobutton.

Alterar a propriedade Name:

Form1 = FrmCalculadora
Label1 = LblN1
Label2 = LblN2
Label3 =LblResultado
Edit1 = EdtN1
Edit2 = EdtN2
Edit3 = EdtResultado
Button1 = BtnCalcular
Button2 = BtnLimpar
Button3 = BtnSair
RadioButton1 = RdBtnSoma
RadioButton2 = RdBtnSubtracao
RadioButton3 = RdBtnMultiplicacao
RadioButton4 = RdBtnDivisao

Após alteras a propriedade Name dos Componentes o Formulário e o Object Inspector terá a seguinte aparência

Alterar as propriedades Caption / text:

FrmCalculadora: caption = Calculadora
LblN1: caption = Número 1
LblN2: caption = Número 2
LblResultado: caption = Resultado
EdtN1: text = vazio (em branco)
EdtN2: text = vazio (em branco)
EdtResultado: text = vazio (em branco)
BtnCalcular: caption = Calcular
BtnLimpar: caption = Limpar
BtnSair: caption = Sair
RdBtnSoma: caption = Soma
RdBtnSubtracao: caption = Subtração
RdBtnMultiplicacao: caption = Multiplicação
RdBtnDivisao: caption = Divisão

Após alteras a propriedade Caption/Text dos Componentes o Formulário e o Object Inspector terá a seguinte aparência:

Alterar a propriedade ReadOnly do EdtResultado para True. Com isso, esse componente terá a capacidad3e de apresentar um valor, não permitindo a sua alteração.

Para programar o botão Calcular, duplo clique nesse botão. Inserir o código:

=======================================================
procedure TFrmCalculadora.BtnCalcularClick(Sender: TObject);
Var A, B, R : real;
begin
  if ((EdtN1.text = '') or (EdtN2.text = ''))
    then ShowMessage ('Preencha os campos número 1 e o númer 2')
    else
    begin
      A := StrToFloat(EdtN1.text);
      B := StrToFloat(EdtN2.text);
      if (RdBtnSoma.checked)
        then R := A + B
        else if (RdBtnSubtracao.checked)
          then R := A - B
          else if (RdBtnMultiplicacao.checked)
            then R := A * B
            else if (RdBtnDivisao.checked)
              then if (B = 0)
                then
                begin
                  EdtResultado.text := 'Erro';
                  ShowMessage('Número 2 deve ser diferente de zero');
                end
                else R := A / B;
  end;
  if (RdBtnDivisao.checked=false)or(b<>0)
    then EdtResultado.text := FormatFloat('0.00;-0.00;zerado', R);
  if ((EdtN1.text = '') or (EdtN2.text = ''))
    then EdtResultado.text := '';
  EdtN1.setFocus;
end;
=======================================================

Para programar o botão Sair e Limpar.

Duplo clique no botão Sair:
=======================================================
Close
=======================================================

Duplo clique no botão Limpar:
=======================================================
EdtN1.text := '';
EdtN2.text := '';
EdtResultado.text := '';
RdBtnSoma.Checked := True
=======================================================

Referência


MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Exercício do triângulo

-->

Faça um programa que receba o valor dos três lados de um triângulo e mostre a seguinte informação (showmessage = Não é triângulo) ou (showmessage = Triângulo equilátero) ou (showmessage = Triângulo escaleno) ou (showmessage = Triângulo isósceles).

Duplo clique no botão calcular para "programá-lo" , o código encontra-se abaixo.

============================================

 procedure TForm1.BtnCalcularClick(Sender: TObject);
var A, B, C : Integer;
begin
     A := StrToInt(edtA.text);
     B := StrToInt(edtB.text);
     C := StrToInt(edtC.text);
     if (A < B+C ) and (B < A+C) and (C < A+B)
     then
        if (A = B) and (B = C)
        then
           ShowMessage ('Triângulo Equilátero')
        else
            if (A = B) or (A = C) or (C = B)
            then
                ShowMessage ('Triângulo Isósceles')
            else
                ShowMessage ('Triângulo Escaleno')
     else
         ShowMessage ('Não é Triângulo');
     edtA.SetFocus
end;  

============================================

 

-->

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Aplicação com tipo de dado real

Montar a seguinte interface gráfica

Fazer um programa para somar dois números reais, limpar os dados e sair.

Utilize a função FormatFloat que utiliza dois parâmetros, sendo o primeiro a máscara de formatação e o segundo o valor a ser formatado. O valor formatado é transformado em uma string.

A máscara de formatação que será utilizada é a seguinte ('#,##0.00'), onde

# (tralha) estabelece a supressão de valores zerados, quando eles existirem;
, (vírgula) estabelece a separação de milhares (notação norte-americana);
. (ponto) estabelece a separação do ponto para casas decimais (notação norte-americana).

Exemplos de exibição para o número 2.546,58 e o número 44,32:
0,000.00 exibirá 2,546.58 e 0,044.32
#,##0.00 exibirá 2,546.58 e 44.32

Observe que a utilização de máscaras de formatação possibilita a especificação de três formatos diferentes simultaneamente, separados por ponto-e-vírgula. Com isso é possível ter uma máscara para valores positivos, negativos e zeros. Verifique no código seguinte.

O código encontra-se abaixo:

=================================================
procedure TForm1.Button1Click(Sender: TObject);
var a,b,soma: real;
begin
    if ((edit1.text='') or (edit2.text=''))
    then showmessage('Favor preencher os dois números!')
    else
    begin
        a := strtofloat(edit1.text);
        b := strtofloat(edit2.text);
        soma := a + b;
        label1.caption := formatfloat('#,##0.00;(#,##0.00); zerado', Soma);
    end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
    edit1.text := '';
    edit2.text := '';
    label1.caption := '';
    edit1.setfocus;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
    Close;
end;
=================================================

 Faça o seguinte programa:
1 – obter o valor para a variável HT (horas de trabalho no mês);
2 – obter o valor para a variável VH (valor da hora trabalhada);
3 – obter o valor para a variável PD (percentual de desconto);
4 – Calcular o salário bruto (SB): SB = HT x VH;
5 – Calcular o total de desconto (TD): TD = (PD/100) x SB;
6 – Calcular o salário líquido (SL): SL = SB – tudo;
7 – Apresentar o valor do salário líquido: SL.

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Entrada e saída de dados numéricos

Entrada e saída de dados numéricos

Dados numéricos são apresentados sob o tipo caracteres (string);

Antes de serem repassados ao programa, esses dados numéricos devem ser transformados de caracteres para numérico. E o contrário, quando forem apresentados no formulário;

As funções do FPL que fazem essas tarefas são:

StrToFloat e StrToInt – Transforma de caractere (string) para numérico (real e inteiro respectivamente).

FloatToStr e IntToStr - Transforma de numérico (real e inteiro respectivamente) para caractere (string).

Entrada e saída com tipo de dado inteiro

Monte a seguinte interface gráfica para somar dois números inteiros

Dê um duplo clique no botão Somar e digite o código

--------------------------------------------------------------------
procedure TForm1.Btn1Click(Sender: TObject);
Var a, b, r : integer;
begin
     a := strtoint(Edt1.text);
     b := strtoint(Edt2.text);
     r := a + b;
     Lbl4.caption := inttostr(r);
end;
--------------------------------------------------------------------

Basta executar (F9) e testar.

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.